- The ``RoutesMapper`` class in ``repoze.bfg.urldispatch`` has been

  removed, as well as its documentation.  It had been deprecated since
  0.6.3.  Code in ``repoze.bfg.urldispatch.RoutesModelTraverser``
  which catered to it has also been removed.

- The semantics of the ``route`` ZCML directive have been simplified.
  Previously, it was assumed that to use a route, you wanted to map a
  route to an externally registered view.  The new ``route`` directive
  instead has a ``view`` attribute which is required, specifying the
  dotted path to a view callable.  When a route directive is
  processed, a view is *registered* using the name attribute of the
  route directive as its name and the callable as its value.  The
  ``view_name`` and ``provides`` attributes of the ``route`` directive
  are therefore no longer used.  Effectively, if you were previously
  using the ``route`` directive, it means you must change a pair of
  ZCML directives that look like this::

    <route
       name="home"
       path=""
       view_name="login"
       factory=".models.root.Root"
     />

    <view
       for=".models.root.Root"
       name="login"
       view=".views.login_view"
     />
    
  To a ZCML directive that looks like this::

    <route
       name="home"
       path=""
       view=".views.login_view"
       factory=".models.root.Root"
     />

  In other words, to make old code work, remove the ``view``
  directives that were only there to serve the purpose of backing
  ``route`` directives, and move their ``view=`` attribute into the
  ``route`` directive itself.

  This change also necessitated that the ``name`` attribute of the
  ``route`` directive is now required.  If you were previously using
  ``route`` directives without a ``name`` attribute, you'll need to
  add one (the name is arbitrary, but must be unique among all
  ``route`` and ``view`` statements).

  The ``provides`` attribute of the ``route`` directive has also been
  removed.  This directive specified a sequence of interface types
  that the generated context would be decorated with.  Since route
  views are always generated now for a single interface
  (``repoze.bfg.IRoutesContext``) as opposed to being looked up
  arbitrarily, there is no need to decorate any context to ensure a
  view is found.

- The Routes ``Route`` object used to resolve the match is now put
  into the environment as ``bfg.route`` when URL dispatch is used.

3 files changed, 134 insertions, 219 deletions

diff --git a/repoze/bfg/tests/routesapp/configure.zcml b/repoze/bfg/tests/routesapp/configure.zcml
index 17653615a..01062b6d4 100644
--- a/repoze/bfg/tests/routesapp/configure.zcml
+++ b/repoze/bfg/tests/routesapp/configure.zcml
@@ -4,14 +4,9 @@
 
   <route
     path=":id"
-    provides=".models.IFixture"
-    view_name="default"/>
-
-  <view
-      name="default"
-      view=".views.fixture_view"
-      for=".models.IFixture"
-      permission="repoze.view"
-      />
+    name="default"
+    view=".views.fixture_view"
+    permission="repoze.view"
+   />
 
 </configure>
diff --git a/repoze/bfg/tests/test_urldispatch.py b/repoze/bfg/tests/test_urldispatch.py
index e08e98ca7..e1640bfdf 100644
--- a/repoze/bfg/tests/test_urldispatch.py
+++ b/repoze/bfg/tests/test_urldispatch.py
@@ -1,80 +1,5 @@
 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'}
-        environ.update(kw)
-        return environ
-
-    def _getTargetClass(self):
-        from repoze.bfg.urldispatch import RoutesMapper
-        return RoutesMapper
-
-    def _makeOne(self, get_root):
-        klass = self._getTargetClass()
-        return klass(get_root)
-
-    def test_routes_mapper_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.mapper.environ, environ)
-
-    def test_routes_mapper_route_matches(self):
-        marker = ()
-        get_root = make_get_root(marker)
-        mapper = self._makeOne(get_root)
-        mapper.connect('archives/:action/:article', controller='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.controller, 'foo')
-        self.assertEqual(result.action, 'action1')
-        self.assertEqual(result.article, 'article1')
-
-    def test_routes_mapper_custom_context_factory(self):
-        marker = ()
-        get_root = make_get_root(marker)
-        mapper = self._makeOne(get_root)
-        class Dummy(object):
-            def __init__(self, **kw):
-                self.__dict__.update(kw)
-        mapper.connect('archives/:action/:article', controller='foo',
-                       context_factory=Dummy)
-        environ = self._getEnviron(PATH_INFO='/archives/action1/article1')
-        result = mapper(environ)
-        self.assertEqual(result.controller, '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.failIf(hasattr(result, 'context_factory'))
-
-    def test_url_for(self):
-        marker = ()
-        get_root = make_get_root(marker)
-        mapper = self._makeOne(get_root)
-        mapper.connect('archives/:action/:article', controller='foo')
-        environ = self._getEnviron(PATH_INFO='/archives/action1/article1')
-        result = mapper(environ)
-        from routes import url_for
-        result = url_for(controller='foo', action='action2', article='article2')
-        self.assertEqual(result, '/archives/action2/article2')
-
 class RoutesRootFactoryTests(unittest.TestCase):
     def _getEnviron(self, **kw):
         environ = {'SERVER_NAME':'localhost',
@@ -103,18 +28,19 @@ class RoutesRootFactoryTests(unittest.TestCase):
         marker = ()
         get_root = make_get_root(marker)
         mapper = self._makeOne(get_root)
-        mapper.connect('archives/:action/:article', view_name='foo')
+        mapper.connect('foo', 'archives/:action/:article', foo='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.foo, 'foo')
         self.assertEqual(result.action, 'action1')
         self.assertEqual(result.article, 'article1')
         routing_args = environ['wsgiorg.routing_args'][1]
-        self.assertEqual(routing_args['view_name'], 'foo')
+        self.assertEqual(routing_args['foo'], 'foo')
         self.assertEqual(routing_args['action'], 'action1')
         self.assertEqual(routing_args['article'], 'article1')
+        self.assertEqual(environ['bfg.route'].name, 'foo')
 
     def test_unnamed_root_route_matches(self):
         mapper = self._makeOne(None)
@@ -123,18 +49,28 @@ class RoutesRootFactoryTests(unittest.TestCase):
         result = mapper(environ)
         from repoze.bfg.interfaces import IRoutesContext
         self.failUnless(IRoutesContext.providedBy(result))
+        self.assertEqual(environ['bfg.route'].name, None)
+
+    def test_named_root_route_matches(self):
+        mapper = self._makeOne(None)
+        mapper.connect('root', '')
+        environ = self._getEnviron(PATH_INFO='/')
+        result = mapper(environ)
+        from repoze.bfg.interfaces import IRoutesContext
+        self.failUnless(IRoutesContext.providedBy(result))
+        self.assertEqual(environ['bfg.route'].name, 'root')
 
     def test_unicode_in_route_default(self):
         marker = ()
         get_root = make_get_root(marker)
         mapper = self._makeOne(get_root)
-        class DummyRoute:
+        class DummyRoute2:
             routepath = ':id'
             _factory = None
             _provides = ()
         la = unicode('\xc3\xb1a', 'utf-8')
-        mapper.routematch = lambda *arg: ({la:'id'}, DummyRoute)
-        mapper.connect(':la')
+        mapper.routematch = lambda *arg: ({la:'id'}, DummyRoute2)
+        mapper.connect('whatever', ':la')
         environ = self._getEnviron(PATH_INFO='/foo')
         result = mapper(environ)
         from repoze.bfg.interfaces import IRoutesContext
@@ -146,7 +82,7 @@ class RoutesRootFactoryTests(unittest.TestCase):
     def test_no_fallback_get_root(self):
         marker = ()
         mapper = self._makeOne(None)
-        mapper.connect('wont/:be/:found', view_name='foo')
+        mapper.connect('wont', 'wont/:be/:found')
         environ = self._getEnviron(PATH_INFO='/archives/action1/article1')
         result = mapper(environ)
         from repoze.bfg.urldispatch import RoutesContextNotFound
@@ -163,11 +99,10 @@ class RoutesRootFactoryTests(unittest.TestCase):
             implements(IDummy)
             def __init__(self, **kw):
                 self.__dict__.update(kw)
-        mapper.connect('archives/:action/:article', view_name='foo',
+        mapper.connect('article', 'archives/:action/:article',
                        _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
@@ -176,40 +111,23 @@ class RoutesRootFactoryTests(unittest.TestCase):
         self.failUnless(IDummy.providedBy(result))
         self.failIf(hasattr(result, '_factory'))
 
-    def test_custom_provides(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',
-                       _provides = [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, '_provides'))
-
     def test_has_routes(self):
         mapper = self._makeOne(None)
         self.assertEqual(mapper.has_routes(), False)
-        mapper.connect('archives/:action/:article', view_name='foo')
+        mapper.connect('whatever', 'archives/:action/:article')
         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')
+        mapper.connect('whatever', 'archives/:action/:article')
         environ = self._getEnviron(PATH_INFO='/archives/action1/article1')
+        route = DummyRoute('yo')
+        environ['bfg.route'] = route
         result = mapper(environ)
         from routes import url_for
-        result = url_for(view_name='foo', action='action2', article='article2')
+        result = url_for(action='action2', article='article2')
         self.assertEqual(result, '/archives/action2/article2')
 
 class TestRoutesContextNotFound(unittest.TestCase):
@@ -248,75 +166,29 @@ class RoutesModelTraverserTests(unittest.TestCase):
         from repoze.bfg.interfaces import ITraverser
         verifyObject(ITraverser, self._makeOne(None))
 
-    def test_call_with_only_controller_bwcompat(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], [])
-        self.assertEqual(result[3], None)
-        self.assertEqual(result[4], model)
-        self.assertEqual(result[5], None)
-
-    def test_call_with_only_view_name_bwcompat(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], [])
-        self.assertEqual(result[3], None)
-        self.assertEqual(result[4], model)
-        self.assertEqual(result[5], None)
-
-    def test_call_with_subpath_bwcompat(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'])
-        self.assertEqual(result[3], None)
-        self.assertEqual(result[4], model)
-        self.assertEqual(result[5], None)
-
-    def test_call_with_no_view_name_or_controller_bwcompat(self):
+    def test_it_nothingfancy(self):
         model = DummyContext()
         traverser = self._makeOne(model)
-        result = traverser({})
-        self.assertEqual(result[0], model)
-        self.assertEqual(result[1], '')
-        self.assertEqual(result[2], [])
-        self.assertEqual(result[3], None)
-        self.assertEqual(result[4], model)
-        self.assertEqual(result[5], None)
-
-    def test_call_with_only_view_name(self):
-        model = DummyContext()
-        traverser = self._makeOne(model)
-        routing_args = ((), {'view_name':'view_name'})
-        environ = {'wsgiorg.routing_args': routing_args}
+        routing_args = ((), {})
+        route = DummyRoute('yo')
+        environ = {'wsgiorg.routing_args': routing_args, 'bfg.route': route}
         result = traverser(environ)
         self.assertEqual(result[0], model)
-        self.assertEqual(result[1], 'view_name')
+        self.assertEqual(result[1], 'yo')
         self.assertEqual(result[2], [])
         self.assertEqual(result[3], None)
         self.assertEqual(result[4], model)
         self.assertEqual(result[5], None)
 
-    def test_call_with_view_name_and_subpath(self):
+    def test_call_with_subpath(self):
         model = DummyContext()
         traverser = self._makeOne(model)
-        routing_args = ((), {'view_name':'view_name', 'subpath':'/a/b/c'})
-        environ = {'wsgiorg.routing_args': routing_args}
+        routing_args = ((), {'subpath':'/a/b/c'})
+        route = DummyRoute('yo')
+        environ = {'wsgiorg.routing_args':routing_args, 'bfg.route': route}
         result = traverser(environ)
         self.assertEqual(result[0], model)
-        self.assertEqual(result[1], 'view_name')
+        self.assertEqual(result[1], 'yo')
         self.assertEqual(result[2], ['a', 'b','c'])
         self.assertEqual(result[3], None)
         self.assertEqual(result[4], model)
@@ -325,12 +197,13 @@ class RoutesModelTraverserTests(unittest.TestCase):
     def test_with_path_info(self):
         model = DummyContext()
         traverser = self._makeOne(model)
-        routing_args = ((), {'view_name':'view_name', 'path_info':'foo/bar'})
-        environ = {'wsgiorg.routing_args': routing_args,
+        routing_args = ((), {'path_info':'foo/bar'})
+        route = DummyRoute('yo')
+        environ = {'wsgiorg.routing_args': routing_args, 'bfg.route': route,
                    'PATH_INFO':'/a/b/foo/bar', 'SCRIPT_NAME':''}
         result = traverser(environ)
         self.assertEqual(result[0], model)
-        self.assertEqual(result[1], 'view_name')
+        self.assertEqual(result[1], 'yo')
         self.assertEqual(result[2], [])
         self.assertEqual(result[3], None)
         self.assertEqual(result[4], model)
@@ -341,8 +214,9 @@ class RoutesModelTraverserTests(unittest.TestCase):
     def test_with_path_info_PATH_INFO_w_extra_slash(self):
         model = DummyContext()
         traverser = self._makeOne(model)
-        routing_args = ((), {'view_name':'view_name', 'path_info':'foo/bar'})
-        environ = {'wsgiorg.routing_args': routing_args,
+        routing_args = ((), {'path_info':'foo/bar'})
+        route = DummyRoute('yo')
+        environ = {'wsgiorg.routing_args': routing_args, 'bfg.route':route,
                    'PATH_INFO':'/a/b//foo/bar', 'SCRIPT_NAME':''}
         result = traverser(environ)
         self.assertEqual(environ['PATH_INFO'], '/foo/bar')
@@ -400,3 +274,7 @@ class DummyContext(object):
 class DummyRequest(object):
     """ """
     
+class DummyRoute(object):
+    def __init__(self, name):
+        self.name = name
+        
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index 0d7f1b631..1853483ba 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -269,15 +269,15 @@ class TestConnectRouteFunction(unittest.TestCase):
         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][0], ('name', 'path'))
         self.assertEqual(mapper.connections[0][1], {'requirements': {}})
 
     def test_name_and_path(self):
         mapper = self._registerRoutesMapper()
-        directive = DummyRouteDirective(name='abc')
+        directive = DummyRouteDirective(name='abc', path='thepath')
         self._callFUT(directive)
         self.assertEqual(len(mapper.connections), 1)
-        self.assertEqual(mapper.connections[0][0], ('abc', 'a/b/c',))
+        self.assertEqual(mapper.connections[0][0], ('abc', 'thepath',))
         self.assertEqual(mapper.connections[0][1], {'requirements': {}})
 
     def test_all_directives(self):
@@ -290,28 +290,27 @@ class TestConnectRouteFunction(unittest.TestCase):
             parent_member_name='p', parent_collection_name='c',
             condition_method='GET', condition_subdomain=True,
             condition_function=foo, subdomains=['a'],
-            factory=foo, provides=[IDummy], view_name='def')
+            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], ('a/b/c',))
+        self.assertEqual(mapper.connections[0][0], ('thename', 'thepath'))
         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,
-                          '_factory':foo,
-                          '_provides':[IDummy],
-                          'view_name':'def',
-                          })
+        D = mapper.connections[0][1]
+        
+        self.assertEqual(D['requirements'], {})
+        self.assertEqual(D['_minimize'],True)
+        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)
+        self.assertEqual(D['_factory'], foo)
 
     def test_condition_subdomain_true(self):
         mapper = self._registerRoutesMapper()
@@ -319,7 +318,6 @@ class TestConnectRouteFunction(unittest.TestCase):
                                         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,
@@ -335,7 +333,6 @@ class TestConnectRouteFunction(unittest.TestCase):
                                         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,
@@ -349,7 +346,6 @@ class TestConnectRouteFunction(unittest.TestCase):
                                         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,
@@ -359,11 +355,12 @@ class TestConnectRouteFunction(unittest.TestCase):
 
     def test_subdomains(self):
         mapper = self._registerRoutesMapper()
-        directive = DummyRouteDirective(static=True, explicit=True,
+        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], ('a/b/c',))
+        self.assertEqual(mapper.connections[0][0], ('name', 'path'))
         self.assertEqual(mapper.connections[0][1],
                          {'requirements': {},
                           '_static':True,
@@ -371,7 +368,7 @@ class TestConnectRouteFunction(unittest.TestCase):
                           'conditions':{'sub_domain':['a', 'b']}
                           })
 
-class TestRouteGroupingContextDecorator(unittest.TestCase):
+class TestRoute(unittest.TestCase):
     def setUp(self):
         cleanUp()
 
@@ -382,33 +379,79 @@ class TestRouteGroupingContextDecorator(unittest.TestCase):
         from repoze.bfg.zcml import Route
         return Route
 
-    def _makeOne(self, context, path, **kw):
-        return self._getTargetClass()(context, path, **kw)
+    def _makeOne(self, context, path, name, view, **kw):
+        return self._getTargetClass()(context, path, name, view, **kw)
 
     def test_defaults(self):
         context = DummyContext()
-        route = self._makeOne(context, 'abc')
+        view = Dummy()
+        route = self._makeOne(context, 'path', 'name', view)
+        self.assertEqual(route.path, 'path')
+        self.assertEqual(route.name, 'name')
+        self.assertEqual(route.view, view)
         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',
+        view = Dummy()
+        from zope.configuration.exceptions import ConfigurationError
+        self.assertRaises(ConfigurationError, self._makeOne, context,
+                          'path', 'name', view,
                           parent_member_name='a')
         
     def test_parent_collection_name_present(self):
         context = DummyContext()
-        route = self._makeOne(context, 'abc',
+        view = Dummy()
+        route = self._makeOne(context, 'path', 'name', view,
                               parent_member_name='a',
                               parent_collection_name='p')
         self.assertEqual(route.parent_member_name, 'a')
         self.assertEqual(route.parent_collection_name, 'p')
 
-    def test_explicit_view_name(self):
+    def test_after(self):
+        from repoze.bfg.zcml import handler
+        from repoze.bfg.zcml import connect_route
+        from repoze.bfg.interfaces import IRoutesContext
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IView
+        
         context = DummyContext()
-        route = self._makeOne(context, 'abc', view_name='def')
-        self.assertEqual(route.view_name, 'def')
+        view = Dummy()
+        route = self._makeOne(context, 'path', 'name', view)
+        route.after()
+        actions = context.actions
+        self.assertEqual(len(actions), 2)
+
+        view_action = actions[0]
+        view_callable = view_action['callable']
+        view_discriminator = view_action['discriminator']
+        view_args = view_action['args']
+        self.assertEqual(view_callable, handler)
+        self.assertEqual(len(view_discriminator), 6)
+        self.assertEqual(view_discriminator[0], 'view')
+        self.assertEqual(view_discriminator[1], IRoutesContext)
+        self.assertEqual(view_discriminator[2],'name')
+        self.assertEqual(view_discriminator[3], IRequest)
+        self.assertEqual(view_discriminator[4], IView)
+        self.assertEqual(view_discriminator[5], True)
+        self.assertEqual(view_args, ('registerAdapter', view,
+                                     (IRoutesContext, IRequest), IView,
+                                     'name', None))
+        
+        route_action = actions[1]
+        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), 7)
+        self.assertEqual(route_discriminator[0], 'route')
+        self.assertEqual(route_discriminator[1], 'path')
+        self.assertEqual(route_discriminator[2],'{}')
+        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,))
 
 class TestZCMLPickling(unittest.TestCase):
     i = 0
@@ -760,6 +803,11 @@ class Dummy:
     pass
 
 class DummyRouteDirective:
+    path = 'path'
+    name = 'name'
+    view = None
+    factory = None
+    permission = None
     encoding = None
     static = False
     minimize = False
@@ -775,11 +823,6 @@ class DummyRouteDirective:
     condition_subdomain = None
     condition_function = None
     subdomains = None
-    path = 'a/b/c'
-    name = None
-    view_name = ''
-    factory = None
-    provides = ()
     def __init__(self, **kw):
         if not 'requirements' in kw:
             kw['requirements'] = {}
@@ -796,4 +839,3 @@ from zope.interface import Interface
 class IDummy(Interface):
     pass
 
-