Merge noroutes branch to trunk.

5 files changed, 214 insertions, 339 deletions

diff --git a/repoze/bfg/tests/test_request.py b/repoze/bfg/tests/test_request.py
index d5823e7d7..5f61f4efc 100644
--- a/repoze/bfg/tests/test_request.py
+++ b/repoze/bfg/tests/test_request.py
@@ -1,4 +1,5 @@
 import unittest
+from repoze.bfg.testing import cleanUp
 
 class TestMakeRequestASCII(unittest.TestCase):
     def _callFUT(self, event):
@@ -103,22 +104,35 @@ class Test_HEADRequest(TestRequestSubclass, unittest.TestCase):
         return DEFAULT_REQUEST_FACTORIES['HEAD']['interface']
 
 class TestRequestFactory(unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+        
     def _callFUT(self, environ):
         from repoze.bfg.request import request_factory
         return request_factory(environ)
 
-    def _getRequestFactory(self, name_or_iface=None):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES[name_or_iface]['factory']
-
-    def _makeRoute(self):
-        route = DummyRoute()
+    def _registerRequestFactories(self, name=''):
+        from zope.component import getSiteManager
+        from repoze.bfg.interfaces import IRequestFactories
         factories = {}
         def factory(environ):
             return environ
         for name in (None, 'GET', 'POST', 'PUT', 'DELETE', 'HEAD'):
             factories[name] = {'factory':factory}
-        route.request_factories = factories
+        sm = getSiteManager()
+        sm.registerUtility(factories, IRequestFactories, name=name)
+        if name:
+            sm.registerUtility(factories, IRequestFactories, name='')
+
+    def _getRequestFactory(self, name_or_iface=None):
+        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
+        return DEFAULT_REQUEST_FACTORIES[name_or_iface]['factory']
+
+    def _makeRoute(self, name=None):
+        route = DummyRoute(name)
         return route
 
     def test_no_route_no_request_method(self):
@@ -164,18 +178,21 @@ class TestRequestFactory(unittest.TestCase):
         self.failUnless(IHEADRequest.providedBy(result))
 
     def test_route_no_request_method(self):
+        self._registerRequestFactories()
         route = self._makeRoute()
         environ = {'bfg.routes.route':route}
         result = self._callFUT(environ)
         self.assertEqual(result, environ)
 
     def test_route_unknown(self):
+        self._registerRequestFactories()
         route = self._makeRoute()
         environ = {'bfg.routes.route':route, 'REQUEST_METHOD':'UNKNOWN'}
         result = self._callFUT(environ)
         self.assertEqual(result, environ)
 
     def test_route_known(self):
+        self._registerRequestFactories()
         route = self._makeRoute()
         environ = {'bfg.routes.route':route, 'REQUEST_METHOD':'GET'}
         result = self._callFUT(environ)
@@ -273,7 +290,8 @@ class TestDefaultRequestFactories(unittest.TestCase):
 
 
 class DummyRoute:
-    pass
+    def __init__(self, name):
+        self.name=name
 
 class DummyRequest:
     pass
diff --git a/repoze/bfg/tests/test_traversal.py b/repoze/bfg/tests/test_traversal.py
index 081105f88..68b920fa4 100644
--- a/repoze/bfg/tests/test_traversal.py
+++ b/repoze/bfg/tests/test_traversal.py
@@ -785,11 +785,11 @@ class TraversalContextURLTests(unittest.TestCase):
         one.__name__ = 'one'
         one.__parent__ = root
         route = DummyRoute()
-        route.non_minimized_result = False
+        route.raise_exc = KeyError
         request = DummyRequest({'bfg.routes.route':route,
                                 'bfg.routes.matchdict':{'a':1}})
         context_url = self._makeOne(one, request)
-        self.assertRaises(ValueError, context_url)
+        self.assertRaises(KeyError, context_url)
 
 class TestVirtualRoot(unittest.TestCase):
     def setUp(self):
@@ -1005,15 +1005,10 @@ class DummyContextURL:
         return '123'
 
 class DummyRoute:
-    minimization = False
-
-    minimized_result = 'example/'
-    non_minimized_result = '/example/'
-
-    def generate_minimized(self, kw):
-        self.generate_kw = kw
-        return self.minimized_result
-
-    def generate_non_minimized(self, kw):
+    result = '/example/'
+    raise_exc = None
+    def generate(self, kw):
         self.generate_kw = kw
-        return self.non_minimized_result
+        if self.raise_exc:
+            raise self.raise_exc
+        return self.result
diff --git a/repoze/bfg/tests/test_url.py b/repoze/bfg/tests/test_url.py
index 3c5bd7559..5f0fde872 100644
--- a/repoze/bfg/tests/test_url.py
+++ b/repoze/bfg/tests/test_url.py
@@ -168,31 +168,40 @@ class TestRouteUrl(unittest.TestCase):
         from repoze.bfg.url import route_url
         return route_url(*arg, **kw)
 
-    def test_it(self):
+    def test_with_elements(self):
         from repoze.bfg.interfaces import IRoutesMapper
-        mapper = DummyRoutesMapper({'flub':DummyRoute({})})
+        mapper = DummyRoutesMapper(result='/1/2/3')
         from zope.component import getSiteManager
         sm = getSiteManager()
         sm.registerUtility(mapper, IRoutesMapper)
-        args = {'a':'1', 'b':'2', 'c':'3'}
-        environ = {'SERVER_NAME':'example.com', 'wsgi.url_scheme':'http',
-                   'SERVER_PORT':'80', 'wsgiorg.routing_args':((), args)}
-        request = DummyRequest(environ)
-        result = self._callFUT(request, 'flub', a=1, b=2, c=3)
-        self.assertEqual(result, 'http://example.com/1/2/3')
+        request = DummyRequest()
+        result = self._callFUT('flub', request, 'extra1', 'extra2',
+                               a=1, b=2, c=3, _query={'a':1},
+                               _anchor=u"foo")
+        self.assertEqual(result,
+                         'http://example.com:5432/1/2/3/extra1/extra2?a=1#foo')
+
+    def test_no_elements(self):
+        from repoze.bfg.interfaces import IRoutesMapper
+        mapper = DummyRoutesMapper(result='/1/2/3')
+        from zope.component import getSiteManager
+        sm = getSiteManager()
+        sm.registerUtility(mapper, IRoutesMapper)
+        request = DummyRequest()
+        result = self._callFUT('flub', request, a=1, b=2, c=3, _query={'a':1},
+                               _anchor=u"foo")
+        self.assertEqual(result,
+                         'http://example.com:5432/1/2/3?a=1#foo')
 
     def test_it_generation_error(self):
         from repoze.bfg.interfaces import IRoutesMapper
-        mapper = DummyRoutesMapper({'flub':DummyRoute({})})
+        mapper = DummyRoutesMapper(raise_exc=KeyError)
         from zope.component import getSiteManager
         sm = getSiteManager()
         sm.registerUtility(mapper, IRoutesMapper)
-        args = {'a':'1', 'b':'2', 'c':'3'}
-        mapper.raise_exc = True
-        environ = {'SERVER_NAME':'example.com', 'wsgi.url_scheme':'http',
-                   'SERVER_PORT':'80', 'wsgiorg.routing_args':((), args)}
-        request = DummyRequest(environ)
-        self.assertRaises(ValueError, self._callFUT, request, 'flub', a=1)
+        mapper.raise_exc = KeyError
+        request = DummyRequest()
+        self.assertRaises(KeyError, self._callFUT, 'flub', request, a=1)
         
 class DummyContext(object):
     def __init__(self, next=None):
@@ -206,24 +215,12 @@ class DummyRequest:
         self.environ = environ
 
 class DummyRoutesMapper:
-    encoding = 'utf-8'
-    hardcode_names = False
-    sub_domains = []
-    raise_exc = False
-    def __init__(self, routes, generate_result='/1/2/3', raise_exc=False):
-        self._routenames = routes
-        self.generate_result = generate_result
+    raise_exc = None
+    def __init__(self, result='/1/2/3', raise_exc=False):
+        self.result = result
         
     def generate(self, *route_args, **newargs):
         if self.raise_exc:
-            from routes.util import GenerationException
-            raise GenerationException
-        return self.generate_result
+            raise self.raise_exc
+        return self.result
     
-class DummyRoute:
-    filter = None
-    static = False
-    def __init__(self, defaults):
-        self.defaults = defaults
-        
-        
diff --git a/repoze/bfg/tests/test_urldispatch.py b/repoze/bfg/tests/test_urldispatch.py
index 68fda032d..cdb99b7f4 100644
--- a/repoze/bfg/tests/test_urldispatch.py
+++ b/repoze/bfg/tests/test_urldispatch.py
@@ -1,6 +1,33 @@
 import unittest
 from repoze.bfg.testing import cleanUp
 
+class TestRoute(unittest.TestCase):
+    def _getTargetClass(self):
+        from repoze.bfg.urldispatch import Route
+        return Route
+
+    def _makeOne(self, *arg):
+        return self._getTargetClass()(*arg)
+
+    def test_ctor(self):
+        route = self._makeOne('name', 'matcher', 'generator', 'factory')
+        self.assertEqual(route.name, 'name')
+        self.assertEqual(route.matcher, 'matcher')
+        self.assertEqual(route.generator, 'generator')
+        self.assertEqual(route.factory, 'factory')
+
+    def test_match(self):
+        def matcher(path):
+            return 123
+        route = self._makeOne('name', matcher, 'generator', 'factory')
+        self.assertEqual(route.match('whatever'), 123)
+        
+    def test_generate(self):
+        def generator(path):
+            return 123
+        route = self._makeOne('name', 'matcher', generator, 'factory')
+        self.assertEqual(route.generate({}), 123)
+
 class RoutesRootFactoryTests(unittest.TestCase):
     def setUp(self):
         cleanUp()
@@ -27,42 +54,40 @@ class RoutesRootFactoryTests(unittest.TestCase):
         self.assertEqual(mapper.default_root_factory, None)
 
     def test_no_route_matches(self):
-        get_root = make_get_root(123)
+        get_root = DummyRootFactory(123)
         mapper = self._makeOne(get_root)
         environ = self._getEnviron(PATH_INFO='/')
         result = mapper(environ)
         self.assertEqual(result, 123)
-        self.assertEqual(mapper.environ, environ)
 
     def test_route_matches(self):
-        get_root = make_get_root(123)
+        get_root = DummyRootFactory(123)
         mapper = self._makeOne(get_root)
-        mapper.connect('foo', 'archives/:action/:article', foo='foo')
+        mapper.connect('foo', 'archives/:action/:article')
         environ = self._getEnviron(PATH_INFO='/archives/action1/article1')
         result = mapper(environ)
         self.assertEqual(result, 123)
         routing_args = environ['wsgiorg.routing_args'][1]
-        self.assertEqual(routing_args['foo'], 'foo')
         self.assertEqual(routing_args['action'], 'action1')
         self.assertEqual(routing_args['article'], 'article1')
         self.assertEqual(environ['bfg.routes.matchdict'], routing_args)
         self.assertEqual(environ['bfg.routes.route'].name, 'foo')
 
-    def test_unnamed_root_route_matches(self):
-        root_factory = make_get_root(123)
+    def test_root_route_matches(self):
+        root_factory = DummyRootFactory(123)
         mapper = self._makeOne(root_factory)
-        mapper.connect('')
+        mapper.connect('root', '')
         environ = self._getEnviron(PATH_INFO='/')
         result = mapper(environ)
         self.assertEqual(result, 123)
-        self.assertEqual(environ['bfg.routes.route'].name, None)
+        self.assertEqual(environ['bfg.routes.route'].name, 'root')
         self.assertEqual(environ['bfg.routes.matchdict'], {})
         self.assertEqual(environ['wsgiorg.routing_args'], ((), {}))
 
-    def test_named_root_route_matches(self):
-        root_factory = make_get_root(123)
+    def test_root_route_matches2(self):
+        root_factory = DummyRootFactory(123)
         mapper = self._makeOne(root_factory)
-        mapper.connect('root', '')
+        mapper.connect('root', '/')
         environ = self._getEnviron(PATH_INFO='/')
         result = mapper(environ)
         self.assertEqual(result, 123)
@@ -70,25 +95,8 @@ class RoutesRootFactoryTests(unittest.TestCase):
         self.assertEqual(environ['bfg.routes.matchdict'], {})
         self.assertEqual(environ['wsgiorg.routing_args'], ((), {}))
 
-    def test_unicode_in_route_default(self):
-        root_factory = make_get_root(123)
-        mapper = self._makeOne(root_factory)
-        class DummyRoute:
-            routepath = ':id'
-            _factory = None
-        la = unicode('\xc3\xb1a', 'utf-8')
-        mapper.routematch = lambda *arg: ({la:'id'}, DummyRoute)
-        mapper.connect('whatever', ':la')
-        environ = self._getEnviron(PATH_INFO='/foo')
-        result = mapper(environ)
-        self.assertEqual(result, 123)
-        self.assertEqual(environ['bfg.routes.route'], DummyRoute)
-        self.assertEqual(environ['bfg.routes.matchdict'], {u'\xf1a': 'id'})
-        routing_args = environ['wsgiorg.routing_args'][1]
-        self.assertEqual(routing_args[la], 'id')
-
     def test_fallback_to_default_root_factory(self):
-        root_factory = make_get_root(123)
+        root_factory = DummyRootFactory(123)
         mapper = self._makeOne(root_factory)
         mapper.connect('wont', 'wont/:be/:found')
         environ = self._getEnviron(PATH_INFO='/archives/action1/article1')
@@ -101,20 +109,50 @@ class RoutesRootFactoryTests(unittest.TestCase):
         mapper.connect('whatever', 'archives/:action/:article')
         self.assertEqual(mapper.has_routes(), True)
 
-    def test_url_for(self):
-        root_factory = make_get_root(None)
-        mapper = self._makeOne(root_factory)
-        mapper.connect('whatever', 'archives/:action/:article')
-        environ = self._getEnviron(PATH_INFO='/archives/action1/article1')
-        result = mapper(environ)
-        from routes import url_for
-        result = url_for(action='action2', article='article2')
-        self.assertEqual(result, '/archives/action2/article2')
+    def test_generate(self):
+        mapper = self._makeOne(None)
+        def generator(kw):
+            return 123
+        route = DummyRoute(generator)
+        mapper.routes['abc'] =  route
+        self.assertEqual(mapper.generate('abc', {}), 123)
 
-def make_get_root(result):
-    def dummy_get_root(environ):
-        return result
-    return dummy_get_root
+class TestCompileRoute(unittest.TestCase):
+    def _callFUT(self, path):
+        from repoze.bfg.urldispatch import _compile_route
+        return _compile_route(path)
+
+    def test_no_star(self):
+        matcher, generator = self._callFUT('/foo/:baz/biz/:buz/bar')
+        self.assertEqual(matcher('/foo/baz/biz/buz/bar'),
+                         {'baz':'baz', 'buz':'buz'})
+        self.assertEqual(matcher('foo/baz/biz/buz/bar'), None)
+        self.assertEqual(generator({'baz':1, 'buz':2}), '/foo/1/biz/2/bar')
+
+    def test_with_star(self):
+        matcher, generator = self._callFUT('/foo/:baz/biz/:buz/bar*traverse')
+        self.assertEqual(matcher('/foo/baz/biz/buz/bar'),
+                         {'baz':'baz', 'buz':'buz', 'traverse':''})
+        self.assertEqual(matcher('/foo/baz/biz/buz/bar/everything/else/here'),
+                         {'baz':'baz', 'buz':'buz',
+                          'traverse':'/everything/else/here'})
+        self.assertEqual(matcher('foo/baz/biz/buz/bar'), None)
+        self.assertEqual(generator(
+            {'baz':1, 'buz':2, 'traverse':u'/a/b'}), '/foo/1/biz/2/bar/a/b')
+
+    def test_no_beginning_slash(self):
+        matcher, generator = self._callFUT('foo/:baz/biz/:buz/bar')
+        self.assertEqual(matcher('/foo/baz/biz/buz/bar'),
+                         {'baz':'baz', 'buz':'buz'})
+        self.assertEqual(matcher('foo/baz/biz/buz/bar'), None)
+        self.assertEqual(generator({'baz':1, 'buz':2}), '/foo/1/biz/2/bar')
+
+
+class DummyRootFactory(object):
+    def __init__(self, result):
+        self.result = result
+    def __call__(self, environ):
+        return self.result
 
 class DummyContext(object):
     """ """
@@ -122,3 +160,7 @@ class DummyContext(object):
 class DummyRequest(object):
     """ """
     
+class DummyRoute(object):
+    def __init__(self, generator):
+        self.generate = generator
+        
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index 84c794e89..1a0ee3c3f 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -472,12 +472,16 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(regadapt['args'][2], (IFoo, IDummy))
 
     def test_with_route_name(self):
+        from zope.component import getSiteManager
+        from repoze.bfg.interfaces import IRequestFactories
         class IFoo:
             pass
         class IDummyRequest:
             pass
         context = DummyContext()
-        context.request_factories = {'foo':{None:{'interface':IDummyRequest}}}
+        factories = {None:{'interface':IDummyRequest}}
+        sm = getSiteManager()
+        sm.registerUtility(factories, IRequestFactories, name='foo')
         view = lambda *arg: None
         self._callFUT(context, 'repoze.view', IFoo, view=view, route_name='foo')
         actions = context.actions
@@ -671,19 +675,6 @@ class TestDeriveView(unittest.TestCase):
         self.failUnless('instance' in result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-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()
@@ -691,9 +682,9 @@ class TestConnectRouteFunction(unittest.TestCase):
     def tearDown(self):
         cleanUp()
         
-    def _callFUT(self, directive):
+    def _callFUT(self, name, path, factory):
         from repoze.bfg.zcml import connect_route
-        return connect_route(directive)
+        return connect_route(name, path, factory)
 
     def _registerRoutesMapper(self):
         from zope.component import getGlobalSiteManager
@@ -703,145 +694,10 @@ class TestConnectRouteFunction(unittest.TestCase):
         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], ('name', 'path'))
-        self.assertEqual(mapper.connections[0][1], {'requirements': {}})
-
-    def test_name_and_path(self):
-        mapper = self._registerRoutesMapper()
-        directive = DummyRouteDirective(name='abc', path='thepath')
-        self._callFUT(directive)
-        self.assertEqual(len(mapper.connections), 1)
-        self.assertEqual(mapper.connections[0][0], ('abc', 'thepath',))
-        self.assertEqual(mapper.connections[0][1], {'requirements': {}})
-
-    def test_all_directives(self):
-        mapper = self._registerRoutesMapper()
-        def foo():
-            """ """
-        directive = DummyRouteDirective(
-            minimize=False, 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'],
-            name='thename', path='thepath',
-            factory=foo, view='view', permission='permission')
-        self._callFUT(directive)
-        self.assertEqual(len(mapper.connections), 1)
-        self.assertEqual(mapper.connections[0][0], ('thename', 'thepath'))
-        pr = {'member_name':'p', 'collection_name':'c'}
-        c = {'method':'GET', 'sub_domain':['a'], 'function':foo}
-        D = mapper.connections[0][1]
-        
-        self.assertEqual(D['requirements'], {})
-        self.assertEqual(D['_minimize'],False)
-        self.assertEqual(D['_explicit'],True)
-        self.assertEqual(D['_encoding'],'utf-8')
-        self.assertEqual(D['_static'],True)
-        self.assertEqual(D['_filter'],foo)
-        self.assertEqual(D['_absolute'],True)
-        self.assertEqual(D['_member_name'], 'm')
-        self.assertEqual(D['_collection_name'], 'c')
-        self.assertEqual(D['_parent_resource'], pr)
-        self.assertEqual(D['conditions'], c)
-        route = mapper.matchlist[-1]
-        self.assertEqual(route._factory, foo)
-        self.assertEqual(route.request_factories,
-                         directive.context.request_factories['thename'])
-        
-
-    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][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][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][1],
-                         {'requirements': {},
-                          '_static':True,
-                          '_explicit':True,
-                          'conditions':{'method':'GET'}
-                          })
-
-    def test_request_type(self):
-        mapper = self._registerRoutesMapper()
-        directive = DummyRouteDirective(static=True, explicit=True,
-                                        request_type='GET')
-        self._callFUT(directive)
-        self.assertEqual(len(mapper.connections), 1)
-        self.assertEqual(mapper.connections[0][1],
-                         {'requirements': {},
-                          '_static':True,
-                          '_explicit':True,
-                          'conditions':{'method':'GET'}
-                          })
-
-    def test_condition_method_and_request_type(self):
-        mapper = self._registerRoutesMapper()
-        directive = DummyRouteDirective(static=True, explicit=True,
-                                        request_type='GET',
-                                        condition_method='POST')
-        self._callFUT(directive)
-        self.assertEqual(len(mapper.connections), 1)
-        self.assertEqual(mapper.connections[0][1],
-                         {'requirements': {},
-                          '_static':True,
-                          '_explicit':True,
-                          'conditions':{'method':'POST'}
-                          })
-
-
-    def test_subdomains(self):
-        mapper = self._registerRoutesMapper()
-        directive = DummyRouteDirective(name='name',
-                                        static=True, explicit=True,
-                                        subdomains=['a', 'b'])
-        self._callFUT(directive)
-        self.assertEqual(len(mapper.connections), 1)
-        self.assertEqual(mapper.connections[0][0], ('name', 'path'))
-        self.assertEqual(mapper.connections[0][1],
-                         {'requirements': {},
-                          '_static':True,
-                          '_explicit':True,
-                          'conditions':{'sub_domain':['a', 'b']}
-                          })
+        self._callFUT('name', 'path', 'factory')
+        self.assertEqual(mapper.connections, [('name', 'path', 'factory')])
 
 class TestRouteDirective(unittest.TestCase):
     def setUp(self):
@@ -850,48 +706,32 @@ class TestRouteDirective(unittest.TestCase):
     def tearDown(self):
         cleanUp()
 
-    def _getTargetClass(self):
-        from repoze.bfg.zcml import Route
-        return Route
-
-    def _makeOne(self, context, path, name, **kw):
-        return self._getTargetClass()(context, path, name, **kw)
+    def _callFUT(self, *arg, **kw):
+        from repoze.bfg.zcml import route
+        return route(*arg, **kw)
 
     def test_defaults(self):
+        from zope.component import getUtility
+        from repoze.bfg.interfaces import IRequestFactories
         context = DummyContext()
-        route = self._makeOne(context, 'path', 'name')
-        self.assertEqual(route.path, 'path')
-        self.assertEqual(route.name, 'name')
-        self.assertEqual(route.requirements, {})
-
-    def test_parent_collection_name_missing(self):
-        context = DummyContext()
-        from zope.configuration.exceptions import ConfigurationError
-        self.assertRaises(ConfigurationError, self._makeOne, context,
-                          'path', 'name', parent_member_name='a')
-        
-    def test_parent_collection_name_present(self):
-        context = DummyContext()
-        route = self._makeOne(context, 'path', 'name',
-                              parent_member_name='a',
-                              parent_collection_name='p')
-        self.assertEqual(route.parent_member_name, 'a')
-        self.assertEqual(route.parent_collection_name, 'p')
+        self._callFUT(context, 'name', 'path')
+        self.failUnless(getUtility(IRequestFactories, name='name'))
 
-    def test_after_with_view(self):
+    def test_with_view(self):
+        from zope.component import getUtility
+        from repoze.bfg.interfaces import IRequestFactories
         from repoze.bfg.zcml import handler
         from repoze.bfg.zcml import connect_route
         from repoze.bfg.interfaces import IView
         
         context = DummyContext()
         view = Dummy()
-        route = self._makeOne(context, 'path', 'name', view=view)
-        route.after()
+        self._callFUT(context, 'name', 'path', view=view)
         actions = context.actions
         self.assertEqual(len(actions), 2)
 
-        factories = context.request_factories
-        request_iface = factories['name'][None]['interface']
+        factories = getUtility(IRequestFactories, name='name')
+        request_iface = factories[None]['interface']
 
         view_action = actions[0]
         view_callable = view_action['callable']
@@ -913,31 +753,28 @@ class TestRouteDirective(unittest.TestCase):
         route_discriminator = route_action['discriminator']
         route_args = route_action['args']
         self.assertEqual(route_callable, connect_route)
-        self.assertEqual(len(route_discriminator), 7)
+        self.assertEqual(len(route_discriminator), 4)
         self.assertEqual(route_discriminator[0], 'route')
         self.assertEqual(route_discriminator[1], 'name')
-        self.assertEqual(route_discriminator[2],'{}')
+        self.assertEqual(route_discriminator[2], None)
         self.assertEqual(route_discriminator[3], None)
-        self.assertEqual(route_discriminator[4], None)
-        self.assertEqual(route_discriminator[5], None)
-        self.assertEqual(route_discriminator[6], None)
-        self.assertEqual(route_args, (route,))
+        self.assertEqual(route_args, ('name', 'path', None))
 
-    def test_after_with_view_and_view_for(self):
+    def test_with_view_and_view_for(self):
+        from zope.component import getUtility
+        from repoze.bfg.interfaces import IRequestFactories
         from repoze.bfg.zcml import handler
         from repoze.bfg.zcml import connect_route
         from repoze.bfg.interfaces import IView
         
         context = DummyContext()
         view = Dummy()
-        route = self._makeOne(context, 'path', 'name', view=view,
-                              view_for=IDummy)
-        route.after()
+        self._callFUT(context, 'name', 'path', view=view, view_for=IDummy)
         actions = context.actions
         self.assertEqual(len(actions), 2)
 
-        factories = context.request_factories
-        request_iface = factories['name'][None]['interface']
+        factories = getUtility(IRequestFactories, 'name')
+        request_iface = factories[None]['interface']
 
         view_action = actions[0]
         view_callable = view_action['callable']
@@ -959,23 +796,21 @@ class TestRouteDirective(unittest.TestCase):
         route_discriminator = route_action['discriminator']
         route_args = route_action['args']
         self.assertEqual(route_callable, connect_route)
-        self.assertEqual(len(route_discriminator), 7)
+        self.assertEqual(len(route_discriminator), 4)
         self.assertEqual(route_discriminator[0], 'route')
         self.assertEqual(route_discriminator[1], 'name')
-        self.assertEqual(route_discriminator[2],'{}')
+        self.assertEqual(route_discriminator[2], IDummy)
         self.assertEqual(route_discriminator[3], None)
-        self.assertEqual(route_discriminator[4], None)
-        self.assertEqual(route_discriminator[5], None)
-        self.assertEqual(route_discriminator[6], None)
-        self.assertEqual(route_args, (route,))
+        self.assertEqual(route_args, ('name', 'path', None,))
 
-    def test_after_without_view(self):
+    def test_without_view(self):
+        from zope.component import getUtility
+        from repoze.bfg.interfaces import IRequestFactories
         from repoze.bfg.zcml import connect_route
         
         context = DummyContext()
         view = Dummy()
-        route = self._makeOne(context, 'path', 'name')
-        route.after()
+        self._callFUT(context, 'name', 'path')
         actions = context.actions
         self.assertEqual(len(actions), 1)
 
@@ -984,15 +819,35 @@ class TestRouteDirective(unittest.TestCase):
         route_discriminator = route_action['discriminator']
         route_args = route_action['args']
         self.assertEqual(route_callable, connect_route)
-        self.assertEqual(len(route_discriminator), 7)
+        self.assertEqual(len(route_discriminator), 4)
         self.assertEqual(route_discriminator[0], 'route')
         self.assertEqual(route_discriminator[1], 'name')
-        self.assertEqual(route_discriminator[2],'{}')
+        self.assertEqual(route_discriminator[2], None)
         self.assertEqual(route_discriminator[3], None)
-        self.assertEqual(route_discriminator[4], None)
-        self.assertEqual(route_discriminator[5], None)
-        self.assertEqual(route_discriminator[6], None)
-        self.assertEqual(route_args, (route,))
+        self.assertEqual(route_args, ('name','path', None))
+
+    def test_with_request_type(self):
+        from zope.component import getUtility
+        from repoze.bfg.interfaces import IRequestFactories
+        from repoze.bfg.zcml import connect_route
+        
+        context = DummyContext()
+        view = Dummy()
+        self._callFUT(context, 'name', 'path', request_type="GET")
+        actions = context.actions
+        self.assertEqual(len(actions), 1)
+
+        route_action = actions[0]
+        route_callable = route_action['callable']
+        route_discriminator = route_action['discriminator']
+        route_args = route_action['args']
+        self.assertEqual(route_callable, connect_route)
+        self.assertEqual(len(route_discriminator), 4)
+        self.assertEqual(route_discriminator[0], 'route')
+        self.assertEqual(route_discriminator[1], 'name')
+        self.assertEqual(route_discriminator[2], None)
+        self.assertEqual(route_discriminator[3], 'GET')
+        self.assertEqual(route_args, ('name','path', None))
 
 class TestZCMLConfigure(unittest.TestCase):
     i = 0
@@ -1360,44 +1215,12 @@ class DummyContext:
 class Dummy:
     pass
 
-class DummyRouteDirective:
-    path = 'path'
-    name = 'name'
-    view = None
-    view_for = None
-    permission = None
-    factory = None
-    minimize = True
-    encoding = None
-    static = False
-    filter = None
-    absolute = False
-    member_name = None
-    collection_name = None
-    condition_method = None
-    request_type = None
-    condition_subdomain = None
-    condition_function = None
-    parent_member_name = None
-    parent_collection_name = None
-    subdomains = None
-    explicit = False
-
-    def __init__(self, **kw):
-        if not 'requirements' in kw:
-            kw['requirements'] = {}
-        self.__dict__.update(kw)
-        self.context = DummyContext()
-        self.context.request_factories = {self.name:{}}
-
 class DummyMapper:
     def __init__(self):
         self.connections = []
-        self.matchlist = []
 
-    def connect(self, *arg, **kw):
-        self.connections.append((arg, kw))
-        self.matchlist.append(DummyRoute())
+    def connect(self, *args):
+        self.connections.append(args)
 
 class DummyRoute:
     pass