finished paster views command and 100% test coverage

4 files changed, 604 insertions, 36 deletions

diff --git a/pyramid/config.py b/pyramid/config.py
index ef520e053..6206d64c4 100644
--- a/pyramid/config.py
+++ b/pyramid/config.py
@@ -2441,7 +2441,7 @@ def _make_predicates(xhr=None, request_method=None, path_info=None,
     if xhr:
         def xhr_predicate(context, request):
             return request.is_xhr
-        xhr_predicate.__text__ = "XHR = True"
+        xhr_predicate.__text__ = "xhr = True"
         weights.append(1 << 1)
         predicates.append(xhr_predicate)
         h.update('xhr:%r' % bool(xhr))
@@ -2449,7 +2449,7 @@ def _make_predicates(xhr=None, request_method=None, path_info=None,
     if request_method is not None:
         def request_method_predicate(context, request):
             return request.method == request_method
-        msg = "Request method = %s"
+        msg = "request method = %s"
         request_method_predicate.__text__ = msg % request_method
         weights.append(1 << 2)
         predicates.append(request_method_predicate)
@@ -2513,6 +2513,7 @@ def _make_predicates(xhr=None, request_method=None, path_info=None,
     if accept is not None:
         def accept_predicate(context, request):
             return accept in request.accept
+        accept_predicate.__text__ = "accept = %s" % accept
         weights.append(1 << 6)
         predicates.append(accept_predicate)
         h.update('accept:%r' % accept)
@@ -2520,6 +2521,7 @@ def _make_predicates(xhr=None, request_method=None, path_info=None,
     if containment is not None:
         def containment_predicate(context, request):
             return find_interface(context, containment) is not None
+        containment_predicate.__text__ = "containment = %s" % containment
         weights.append(1 << 7)
         predicates.append(containment_predicate)
         h.update('containment:%r' % hash(containment))
@@ -2527,6 +2529,8 @@ def _make_predicates(xhr=None, request_method=None, path_info=None,
     if request_type is not None:
         def request_type_predicate(context, request):
             return request_type.providedBy(request)
+        msg = "request type = %s" % request_type
+        request_type_predicate.__text__ = msg
         weights.append(1 << 8)
         predicates.append(request_type_predicate)
         h.update('request_type:%r' % hash(request_type))
@@ -2545,6 +2549,7 @@ def _make_predicates(xhr=None, request_method=None, path_info=None,
             tvalue = tgenerate(m)
             m['traverse'] = traversal_path(tvalue)
             return True
+        traverse_predicate.__text__ = "traverse = True"
         # This isn't actually a predicate, it's just a infodict
         # modifier that injects ``traverse`` into the matchdict.  As a
         # result, the ``traverse_predicate`` function above always
@@ -2554,6 +2559,8 @@ def _make_predicates(xhr=None, request_method=None, path_info=None,
 
     if custom:
         for num, predicate in enumerate(custom):
+            if not hasattr(predicate, '__text__'):
+                predicate.__text__ = "custom predicate"
             predicates.append(predicate)
             # using hash() here rather than id() is intentional: we
             # want to allow custom predicates that are part of
@@ -2668,8 +2675,13 @@ def preserve_view_attrs(view, wrapped_view):
     except AttributeError:
         pass
     try:
+        wrapped_view.__permission__ = view.__permission__
+    except AttributeError:
+        pass
+    try:
         wrapped_view.__predicated__ = view.__predicated__
-        wrapped_view.__predicates__ = view.__predicates__
+        wrapped_view.__predicates__ = [p.__text__
+                                       for p in view.__predicates__]
     except AttributeError:
         pass
     try:
@@ -2757,6 +2769,7 @@ class ViewDeriver(object):
                 raise Forbidden(msg, result)
             _secured_view.__call_permissive__ = view
             _secured_view.__permitted__ = _permitted
+            _secured_view.__permission__ = permission
             wrapped_view = _secured_view
 
         return wrapped_view
@@ -2830,6 +2843,8 @@ class ViewDeriver(object):
         attr_view.__accept__ = accept
         attr_view.__order__ = order
         attr_view.__phash__ = phash
+        attr_view.__view_attr__ = self.kw.get('attr')
+        attr_view.__permission__ = self.kw.get('permission')
         return attr_view
 
     @wraps_view
diff --git a/pyramid/paster.py b/pyramid/paster.py
index 7ff77522e..4437db497 100644
--- a/pyramid/paster.py
+++ b/pyramid/paster.py
@@ -231,6 +231,17 @@ class PViewsCommand(PCommand):
     def out(self, msg): # pragma: no cover
         print msg
     
+    def _find_multi_routes(self, mapper, request):
+        infos = []
+        path = request.environ['PATH_INFO']
+        # find all routes that match path, regardless of predicates
+        for route in mapper.get_routes():
+            match = route.match(path)
+            if match is not None:
+                info = {'match':match, 'route':route}
+                infos.append(info)
+        return infos
+
     def _find_view(self, url, registry):
         """
         Accept ``url`` and ``registry``; create a :term:`request` and
@@ -238,12 +249,14 @@ class PViewsCommand(PCommand):
         configuration` within the application registry; return the view.
         """
         from zope.interface import providedBy
+        from zope.interface import implements
         from pyramid.interfaces import IRequest
         from pyramid.interfaces import IRootFactory
         from pyramid.interfaces import IRouteRequest
         from pyramid.interfaces import IRequestFactory
         from pyramid.interfaces import IRoutesMapper
         from pyramid.interfaces import ITraverser
+        from pyramid.interfaces import IMultiView
         from pyramid.interfaces import IView
         from pyramid.interfaces import IViewClassifier
         from pyramid.request import Request
@@ -258,6 +271,32 @@ class PViewsCommand(PCommand):
         adapters = registry.adapters
         request = None
 
+        class RoutesMultiView(object):
+            implements(IMultiView)
+
+            def __init__(self, infos, context_iface, subpath):
+                self.views = []
+                for info in infos:
+                    match, route = info['match'], info['route']
+                    if route is not None:
+                        request_iface = registry.queryUtility(
+                            IRouteRequest,
+                            name=route.name,
+                            default=IRequest)
+                        view = adapters.lookup(
+                            (IViewClassifier, request_iface, context_iface),
+                            IView, name='', default=None)
+                        if view is None:
+                            continue
+                        view.__predicates__ = [p.__text__
+                                               for p in route.predicates]
+                        view.__route_attrs__ = {'matchdict': match,
+                                               'matched_route': route,
+                                               'subpath': subpath}
+                        view.__view_attr__ = ''
+                        self.views.append((None, view, None))
+
+
         # create the request
         environ = {
             'wsgi.url_scheme':'http',
@@ -268,24 +307,28 @@ class PViewsCommand(PCommand):
             }
         request = request_factory(environ)
         context = None
+        routes_multiview = None
         attrs = request.__dict__
         attrs['registry'] = registry
         request_iface = IRequest
 
         # find the root object
-        root_factory = root_factory
         if routes_mapper is not None:
-            info = routes_mapper(request)
-            match, route = info['match'], info['route']
-            if route is not None:
-                attrs['matchdict'] = match
-                attrs['matched_route'] = route
-
-                request_iface = registry.queryUtility(
-                    IRouteRequest,
-                    name=route.name,
-                    default=IRequest)
-                root_factory = route.factory or root_factory
+            infos = self._find_multi_routes(routes_mapper, request)
+            if len(infos) == 1:
+                info = infos[0]
+                match, route = info['match'], info['route']
+                if route is not None:
+                    attrs['matchdict'] = match
+                    attrs['matched_route'] = route
+
+                    request_iface = registry.queryUtility(
+                        IRouteRequest,
+                        name=route.name,
+                        default=IRequest)
+                    root_factory = route.factory or root_factory
+            if len(infos) > 1:
+                routes_multiview = infos
 
         root = root_factory(request)
         attrs['root'] = root
@@ -303,29 +346,94 @@ class PViewsCommand(PCommand):
 
         # find a view callable
         context_iface = providedBy(context)
-        view_callable = adapters.lookup(
-            (IViewClassifier, request_iface, context_iface),
-            IView, name=view_name, default=None)
-
-        return view_callable
+        if routes_multiview is None:
+            view = adapters.lookup(
+                (IViewClassifier, request_iface, context_iface),
+                IView, name=view_name, default=None)
+        else:
+            view = RoutesMultiView(infos, context_iface, subpath)
+
+        # routes are not registered with a view name
+        if view is None:
+            view = adapters.lookup(
+                (IViewClassifier, request_iface, context_iface),
+                IView, name='', default=None)
+            # we don't want a multiview here
+            if IMultiView.providedBy(view):
+                view = None
+
+        if view is not None:
+            view.__request_attrs__ = attrs
+
+        return view
+
+    def output_route_attrs(self, attrs):
+        if 'matched_route' in attrs:
+            route = attrs['matched_route']
+            self.out("    route name: %s" % route.name)
+            self.out("    route pattern: %s" % route.pattern)
+            self.out("    route path: %s" % route.path)
+            self.out("    subpath: %s" % '/'.join(attrs['subpath']))
+
+    def output_view_attrs(self, attrs):
+        self.out("    context: %s" % attrs['context'])
+        self.out("    view name: %s" % attrs['view_name'])
+
+    def output_multiview_info(self, view_wrapper):
+        name = view_wrapper.__name__
+        module = view_wrapper.__module__
+        attr = view_wrapper.__view_attr__
+        route_attrs = getattr(view_wrapper, '__route_attrs__', {})
+        self.out('')
+        self.out("    View:")
+        self.out("    -----")
+        self.out("    %s.%s.%s" % (module, name, attr))
+        self.output_route_attrs(route_attrs)
+        permission = getattr(view_wrapper, '__permission__', None)
+        if permission is not None:
+            self.out("    required permission = %s" % permission)
+        predicates = getattr(view_wrapper, '__predicates__', None)
+        if predicates is not None:
+            for text in predicates:
+                self.out("    %s" % text)
+
+    def output_view_info(self, view):
+        if view is not None:
+            name = getattr(view, '__name__', view.__class__.__name__)
+            module = view.__module__
+        else:
+            module = 'Not found'
+            name = ''
+        self.out('')
+        self.out("    View:")
+        self.out("    -----")
+        self.out("    %s.%s" % (module, name))
+        permission = getattr(view, '__permission__', None)
+        if permission is not None:
+            self.out("    required permission = %s" % permission)
+        predicates = getattr(view, '__predicates__', None)
+        if predicates is not None:
+            for text in predicates:
+                self.out("    %s" % text)
 
     def command(self):
         from pyramid.interfaces import IMultiView
 
         config_file, section_name, url = self.args
+        if not url.startswith('/'):
+            url = '/%s' % url
         app = self.get_app(config_file, section_name, loadapp=self.loadapp[0])
         registry = app.registry
         view = self._find_view(url, registry)
         self.out('')
-        self.out(url)
+        self.out("URL = %s" % url)
+        if view is not None:
+            self.output_view_attrs(view.__request_attrs__)
+            self.output_route_attrs(view.__request_attrs__)
         if IMultiView.providedBy(view):
             for dummy, view_wrapper, dummy in view.views:
-                self.out('')
-                for p in view_wrapper.__predicates__:
-                    text = getattr(p, '__text__', p.__name__)
-                    self.out("    %s" % text)
-                self.out("    %s" % str(view_wrapper.__original_view__))
+                self.output_multiview_info(view_wrapper)
         else:
-            self.out('')
-            self.out(view)
+            self.output_view_info(view)
+        self.out('')
 
diff --git a/pyramid/tests/test_config.py b/pyramid/tests/test_config.py
index d2ff65878..d5903d4fb 100644
--- a/pyramid/tests/test_config.py
+++ b/pyramid/tests/test_config.py
@@ -4218,7 +4218,7 @@ class Test__make_predicates(unittest.TestCase):
             accept='accept',
             containment='containment',
             request_type='request_type',
-            custom=('a',)
+            custom=(DummyCustomPredicate(),),
             )
         order2, _, _ = self._callFUT(
             xhr='xhr',
@@ -4229,7 +4229,7 @@ class Test__make_predicates(unittest.TestCase):
             accept='accept',
             containment='containment',
             request_type='request_type',
-            custom=('a',)
+            custom=(DummyCustomPredicate(),),
             )
         order3, _, _ = self._callFUT(
             xhr='xhr',
@@ -4322,7 +4322,7 @@ class Test__make_predicates(unittest.TestCase):
             request_type='request_type',
             )
         order9, _, _ = self._callFUT(
-            custom=('a',),
+            custom=(DummyCustomPredicate(),),
             )
         self.failUnless(order1 > order2)
         self.failUnless(order2 > order3)
@@ -4339,7 +4339,7 @@ class Test__make_predicates(unittest.TestCase):
             request_method='request_method',
             )
         order2, _, _ = self._callFUT(
-            custom=('a',),
+            custom=(DummyCustomPredicate(),),
             )
         self.failUnless(order1 < order2)
 
@@ -4349,7 +4349,7 @@ class Test__make_predicates(unittest.TestCase):
             )
         order2, _, _ = self._callFUT(
             request_method='request_method',
-            custom=('a',),
+            custom=(DummyCustomPredicate(),),
             )
         self.failUnless(order1 > order2)
 
@@ -4360,7 +4360,7 @@ class Test__make_predicates(unittest.TestCase):
             )
         order2, _, _ = self._callFUT(
             request_method='request_method',
-            custom=('a',),
+            custom=(DummyCustomPredicate(),),
             )
         self.failUnless(order1 < order2)
 
@@ -4372,7 +4372,7 @@ class Test__make_predicates(unittest.TestCase):
         order2, _, _ = self._callFUT(
             xhr='xhr',
             request_method='request_method',
-            custom=('a',),
+            custom=(DummyCustomPredicate(),),
             )
         self.failUnless(order1 > order2)
 
@@ -4977,6 +4977,10 @@ class DummyStaticURLInfo:
     def add(self, name, spec, **kw):
         self.added.append((name, spec, kw))
 
+class DummyCustomPredicate(object):
+    def __init__(self):
+        self.__text__ = 'custom predicate'
+
 def dummy_view(request):
     return 'OK'
 
diff --git a/pyramid/tests/test_paster.py b/pyramid/tests/test_paster.py
index 35349b7c7..85a79b681 100644
--- a/pyramid/tests/test_paster.py
+++ b/pyramid/tests/test_paster.py
@@ -248,7 +248,419 @@ class TestPRoutesCommand(unittest.TestCase):
         result = command._get_mapper(app)
         self.assertEqual(result.__class__, RoutesMapper)
         
+class TestPViewsCommand(unittest.TestCase):
+    def _getTargetClass(self):
+        from pyramid.paster import PViewsCommand
+        return PViewsCommand
+
+    def _makeOne(self):
+        return self._getTargetClass()('pviews')
+
+    def test__find_view_no_match(self):
+        from pyramid.registry import Registry
+        registry = Registry()
+        self._register_mapper(registry, [])
+        command = self._makeOne()
+        result = command._find_view('/a', registry)
+        self.assertEqual(result, None)
+
+    def test__find_view_no_match_multiview_registered(self):
+        from zope.interface import implements
+        from zope.interface import providedBy
+        from pyramid.interfaces import IRequest
+        from pyramid.interfaces import IViewClassifier
+        from pyramid.interfaces import IMultiView
+        from pyramid.traversal import DefaultRootFactory
+        from pyramid.registry import Registry
+        registry = Registry()
+        class View1(object):
+            implements(IMultiView)
+        request = DummyRequest({'PATH_INFO':'/a'})
+        root = DefaultRootFactory(request)
+        root_iface = providedBy(root)
+        registry.registerAdapter(View1(),
+                                 (IViewClassifier, IRequest, root_iface),
+                                 IMultiView)
+        self._register_mapper(registry, [])
+        command = self._makeOne()
+        result = command._find_view('/x', registry)
+        self.assertEqual(result, None)
+
+    def test__find_view_traversal(self):
+        from zope.interface import providedBy
+        from pyramid.interfaces import IRequest
+        from pyramid.interfaces import IViewClassifier
+        from pyramid.interfaces import IView
+        from pyramid.traversal import DefaultRootFactory
+        from pyramid.registry import Registry
+        registry = Registry()
+        def view1(): pass
+        request = DummyRequest({'PATH_INFO':'/a'})
+        root = DefaultRootFactory(request)
+        root_iface = providedBy(root)
+        registry.registerAdapter(view1,
+                                 (IViewClassifier, IRequest, root_iface),
+                                 IView, name='a')
+        self._register_mapper(registry, [])
+        command = self._makeOne()
+        result = command._find_view('/a', registry)
+        self.assertEqual(result, view1)
+
+    def test__find_view_traversal_multiview(self):
+        from zope.interface import implements
+        from zope.interface import providedBy
+        from pyramid.interfaces import IRequest
+        from pyramid.interfaces import IViewClassifier
+        from pyramid.interfaces import IMultiView
+        from pyramid.traversal import DefaultRootFactory
+        from pyramid.registry import Registry
+        registry = Registry()
+        class View1(object):
+            implements(IMultiView)
+        request = DummyRequest({'PATH_INFO':'/a'})
+        root = DefaultRootFactory(request)
+        root_iface = providedBy(root)
+        view = View1()
+        registry.registerAdapter(view,
+                                 (IViewClassifier, IRequest, root_iface),
+                                 IMultiView, name='a')
+        self._register_mapper(registry, [])
+        command = self._makeOne()
+        result = command._find_view('/a', registry)
+        self.assertEqual(result, view)
+
+    def test__find_view_route_no_multiview(self):
+        from zope.interface import Interface
+        from zope.interface import implements
+        from pyramid.interfaces import IRouteRequest
+        from pyramid.interfaces import IViewClassifier
+        from pyramid.interfaces import IView
+        from pyramid.registry import Registry
+        registry = Registry()
+        def view():pass
+        class IMyRoot(Interface):
+            pass
+        class IMyRoute(Interface):
+            pass
+        registry.registerAdapter(view,
+                                 (IViewClassifier, IMyRoute, IMyRoot),
+                                 IView, '')
+        registry.registerUtility(IMyRoute, IRouteRequest, name='a')
+        class Factory(object):
+            implements(IMyRoot)
+            def __init__(self, request):
+                pass
+        routes = [DummyRoute('a', '/a', factory=Factory),
+                  DummyRoute('b', '/b', factory=Factory, will_match=False)]
+        self._register_mapper(registry, routes)
+        command = self._makeOne()
+        result = command._find_view('/a', registry)
+        self.assertEqual(result, view)
+
+    def test__find_view_route_multiview_no_view_registered(self):
+        from zope.interface import Interface
+        from zope.interface import implements
+        from pyramid.interfaces import IRouteRequest
+        from pyramid.interfaces import IMultiView
+        from pyramid.interfaces import IRootFactory
+        from pyramid.registry import Registry
+        registry = Registry()
+        def view1():pass
+        def view2():pass
+        class IMyRoot(Interface):
+            pass
+        class IMyRoute1(Interface):
+            pass
+        class IMyRoute2(Interface):
+            pass
+        registry.registerUtility(IMyRoute1, IRouteRequest, name='a')
+        registry.registerUtility(IMyRoute2, IRouteRequest, name='b')
+        class Factory(object):
+            implements(IMyRoot)
+            def __init__(self, request):
+                pass
+        registry.registerUtility(Factory, IRootFactory)
+        routes = [DummyRoute('a', '/a'),
+                  DummyRoute('b', '/a')]
+        self._register_mapper(registry, routes)
+        command = self._makeOne()
+        result = command._find_view('/a', registry)
+        self.failUnless(IMultiView.providedBy(result))
+
+    def test__find_view_route_multiview(self):
+        from zope.interface import Interface
+        from zope.interface import implements
+        from pyramid.interfaces import IRouteRequest
+        from pyramid.interfaces import IViewClassifier
+        from pyramid.interfaces import IView
+        from pyramid.interfaces import IMultiView
+        from pyramid.interfaces import IRootFactory
+        from pyramid.registry import Registry
+        registry = Registry()
+        def view1():pass
+        def view2():pass
+        class IMyRoot(Interface):
+            pass
+        class IMyRoute1(Interface):
+            pass
+        class IMyRoute2(Interface):
+            pass
+        registry.registerAdapter(view1,
+                                 (IViewClassifier, IMyRoute1, IMyRoot),
+                                 IView, '')
+        registry.registerAdapter(view2,
+                                 (IViewClassifier, IMyRoute2, IMyRoot),
+                                 IView, '')
+        registry.registerUtility(IMyRoute1, IRouteRequest, name='a')
+        registry.registerUtility(IMyRoute2, IRouteRequest, name='b')
+        class Factory(object):
+            implements(IMyRoot)
+            def __init__(self, request):
+                pass
+        registry.registerUtility(Factory, IRootFactory)
+        routes = [DummyRoute('a', '/a'),
+                  DummyRoute('b', '/a')]
+        self._register_mapper(registry, routes)
+        command = self._makeOne()
+        result = command._find_view('/a', registry)
+        self.failUnless(IMultiView.providedBy(result))
+        self.assertEqual(len(result.views), 2)
+        self.failUnless((None, view1, None) in result.views)
+        self.failUnless((None, view2, None) in result.views)
+
+    def test__find_multi_routes_all_match(self):
+        command = self._makeOne()
+        def factory(request): pass
+        routes = [DummyRoute('a', '/a', factory=factory),
+                  DummyRoute('b', '/a', factory=factory)]
+        mapper = DummyMapper(*routes)
+        request = DummyRequest({'PATH_INFO':'/a'})
+        result = command._find_multi_routes(mapper, request)
+        self.assertEqual(result, [{'match':True, 'route':routes[0]},
+                                  {'match':True, 'route':routes[1]}])
+        
+    def test__find_multi_routes_some_match(self):
+        command = self._makeOne()
+        def factory(request): pass
+        routes = [DummyRoute('a', '/a', factory=factory, will_match=False),
+                  DummyRoute('b', '/a', factory=factory)]
+        mapper = DummyMapper(*routes)
+        request = DummyRequest({'PATH_INFO':'/a'})
+        result = command._find_multi_routes(mapper, request)
+        self.assertEqual(result, [{'match':True, 'route':routes[1]}])
+        
+    def test__find_multi_routes_none_match(self):
+        command = self._makeOne()
+        def factory(request): pass
+        routes = [DummyRoute('a', '/a', factory=factory, will_match=False),
+                  DummyRoute('b', '/a', factory=factory, will_match=False)]
+        mapper = DummyMapper(*routes)
+        request = DummyRequest({'PATH_INFO':'/a'})
+        result = command._find_multi_routes(mapper, request)
+        self.assertEqual(result, [])
         
+    def test_views_command_not_found(self):
+        from pyramid.registry import Registry
+        command = self._makeOne()
+        registry = Registry()
+        L = []
+        command.out = L.append
+        command._find_view = lambda arg1, arg2: None
+        app = DummyApp()
+        app.registry = registry
+        loadapp = DummyLoadApp(app)
+        command.loadapp = (loadapp,)
+        command.args = ('/foo/bar/myapp.ini', 'myapp', '/a')
+        result = command.command()
+        self.assertEqual(result, None)
+        self.assertEqual(L[1], 'URL = /a')
+        self.assertEqual(L[5], '    Not found.')
+
+    def test_views_command_not_found_url_starts_without_slash(self):
+        from pyramid.registry import Registry
+        command = self._makeOne()
+        registry = Registry()
+        L = []
+        command.out = L.append
+        command._find_view = lambda arg1, arg2: None
+        app = DummyApp()
+        app.registry = registry
+        loadapp = DummyLoadApp(app)
+        command.loadapp = (loadapp,)
+        command.args = ('/foo/bar/myapp.ini', 'myapp', 'a')
+        result = command.command()
+        self.assertEqual(result, None)
+        self.assertEqual(L[1], 'URL = /a')
+        self.assertEqual(L[5], '    Not found.')
+
+    def test_views_command_single_view_traversal(self):
+        from pyramid.registry import Registry
+        command = self._makeOne()
+        registry = Registry()
+        L = []
+        command.out = L.append
+        view = DummyView(context='context', view_name='a')
+        command._find_view = lambda arg1, arg2: view
+        app = DummyApp()
+        app.registry = registry
+        loadapp = DummyLoadApp(app)
+        command.loadapp = (loadapp,)
+        command.args = ('/foo/bar/myapp.ini', 'myapp', '/a')
+        result = command.command()
+        self.assertEqual(result, None)
+        self.assertEqual(L[1], 'URL = /a')
+        self.assertEqual(L[2], '    context: context')
+        self.assertEqual(L[3], '    view name: a')
+        self.assertEqual(L[7], '    pyramid.tests.test_paster.DummyView')
+
+    def test_views_command_single_view_traversal_with_permission(self):
+        from pyramid.registry import Registry
+        command = self._makeOne()
+        registry = Registry()
+        L = []
+        command.out = L.append
+        view = DummyView(context='context', view_name='a')
+        view.__permission__ = 'test'
+        command._find_view = lambda arg1, arg2: view
+        app = DummyApp()
+        app.registry = registry
+        loadapp = DummyLoadApp(app)
+        command.loadapp = (loadapp,)
+        command.args = ('/foo/bar/myapp.ini', 'myapp', '/a')
+        result = command.command()
+        self.assertEqual(result, None)
+        self.assertEqual(L[1], 'URL = /a')
+        self.assertEqual(L[2], '    context: context')
+        self.assertEqual(L[3], '    view name: a')
+        self.assertEqual(L[7], '    pyramid.tests.test_paster.DummyView')
+        self.assertEqual(L[8], '    required permission = test')
+
+    def test_views_command_single_view_traversal_with_predicates(self):
+        from pyramid.registry import Registry
+        command = self._makeOne()
+        registry = Registry()
+        L = []
+        command.out = L.append
+        view = DummyView(context='context', view_name='a')
+        view.__predicates__ = ['predicate = x']
+        command._find_view = lambda arg1, arg2: view
+        app = DummyApp()
+        app.registry = registry
+        loadapp = DummyLoadApp(app)
+        command.loadapp = (loadapp,)
+        command.args = ('/foo/bar/myapp.ini', 'myapp', '/a')
+        result = command.command()
+        self.assertEqual(result, None)
+        self.assertEqual(L[1], 'URL = /a')
+        self.assertEqual(L[2], '    context: context')
+        self.assertEqual(L[3], '    view name: a')
+        self.assertEqual(L[7], '    pyramid.tests.test_paster.DummyView')
+        self.assertEqual(L[8], '    predicate = x')
+
+    def test_views_command_single_view_route(self):
+        from pyramid.registry import Registry
+        command = self._makeOne()
+        registry = Registry()
+        L = []
+        command.out = L.append
+        route = DummyRoute('a', '/a')
+        view = DummyView(context='context', view_name='a',
+                         matched_route=route, subpath='')
+        command._find_view = lambda arg1, arg2: view
+        app = DummyApp()
+        app.registry = registry
+        loadapp = DummyLoadApp(app)
+        command.loadapp = (loadapp,)
+        command.args = ('/foo/bar/myapp.ini', 'myapp', '/a')
+        result = command.command()
+        self.assertEqual(result, None)
+        self.assertEqual(L[1], 'URL = /a')
+        self.assertEqual(L[2], '    context: context')
+        self.assertEqual(L[3], '    view name: a')
+        self.assertEqual(L[4], '    route name: a')
+        self.assertEqual(L[5], '    route pattern: /a')
+        self.assertEqual(L[6], '    route path: /a')
+        self.assertEqual(L[7], '    subpath: ')
+        self.assertEqual(L[11], '    pyramid.tests.test_paster.DummyView')
+
+    def test_views_command_multiview(self):
+        from pyramid.registry import Registry
+        command = self._makeOne()
+        registry = Registry()
+        L = []
+        command.out = L.append
+        view = DummyView(context='context')
+        view.__name__ = 'view'
+        view.__view_attr__ = 'call'
+        multiview = DummyMultiView(view, context='context', view_name='a')
+        command._find_view = lambda arg1, arg2: multiview
+        app = DummyApp()
+        app.registry = registry
+        loadapp = DummyLoadApp(app)
+        command.loadapp = (loadapp,)
+        command.args = ('/foo/bar/myapp.ini', 'myapp', '/a')
+        result = command.command()
+        self.assertEqual(result, None)
+        self.assertEqual(L[1], 'URL = /a')
+        self.assertEqual(L[2], '    context: context')
+        self.assertEqual(L[3], '    view name: a')
+        self.assertEqual(L[7], '    pyramid.tests.test_paster.view.call')
+
+    def test_views_command_multiview_with_permission(self):
+        from pyramid.registry import Registry
+        command = self._makeOne()
+        registry = Registry()
+        L = []
+        command.out = L.append
+        view = DummyView(context='context')
+        view.__name__ = 'view'
+        view.__view_attr__ = 'call'
+        view.__permission__ = 'test'
+        multiview = DummyMultiView(view, context='context', view_name='a')
+        command._find_view = lambda arg1, arg2: multiview
+        app = DummyApp()
+        app.registry = registry
+        loadapp = DummyLoadApp(app)
+        command.loadapp = (loadapp,)
+        command.args = ('/foo/bar/myapp.ini', 'myapp', '/a')
+        result = command.command()
+        self.assertEqual(result, None)
+        self.assertEqual(L[1], 'URL = /a')
+        self.assertEqual(L[2], '    context: context')
+        self.assertEqual(L[3], '    view name: a')
+        self.assertEqual(L[7], '    pyramid.tests.test_paster.view.call')
+        self.assertEqual(L[8], '    required permission = test')
+
+    def test_views_command_multiview_with_predicates(self):
+        from pyramid.registry import Registry
+        command = self._makeOne()
+        registry = Registry()
+        L = []
+        command.out = L.append
+        view = DummyView(context='context')
+        view.__name__ = 'view'
+        view.__view_attr__ = 'call'
+        view.__predicates__ = ['predicate = x']
+        multiview = DummyMultiView(view, context='context', view_name='a')
+        command._find_view = lambda arg1, arg2: multiview
+        app = DummyApp()
+        app.registry = registry
+        loadapp = DummyLoadApp(app)
+        command.loadapp = (loadapp,)
+        command.args = ('/foo/bar/myapp.ini', 'myapp', '/a')
+        result = command.command()
+        self.assertEqual(result, None)
+        self.assertEqual(L[1], 'URL = /a')
+        self.assertEqual(L[2], '    context: context')
+        self.assertEqual(L[3], '    view name: a')
+        self.assertEqual(L[7], '    pyramid.tests.test_paster.view.call')
+        self.assertEqual(L[8], '    predicate = x')
+
+    def _register_mapper(self, registry, routes):
+        from pyramid.interfaces import IRoutesMapper
+        mapper = DummyMapper(*routes)
+        registry.registerUtility(mapper, IRoutesMapper)
+
 class TestGetApp(unittest.TestCase):
     def _callFUT(self, config_file, section_name, loadapp):
         from pyramid.paster import get_app
@@ -336,8 +748,37 @@ class DummyMapper(object):
         return self.routes
 
 class DummyRoute(object):
-    def __init__(self, name, pattern, factory=None):
+    def __init__(self, name, pattern, factory=None, will_match=True):
         self.name = name
+        self.path = pattern
         self.pattern = pattern
         self.factory = factory
+        if not will_match:
+            self.will_match = None
+        else:
+            self.will_match = will_match
+        self.predicates = []
+
+    def match(self, route):
+        return self.will_match
         
+class DummyRequest:
+    application_url = 'http://example.com:5432'
+    script_name = ''
+    def __init__(self, environ):
+        self.environ = environ
+        self.matchdict = {}
+
+class DummyView(object):
+    def __init__(self, **attrs):
+        self.__request_attrs__ = attrs
+
+class DummyMultiView(object):
+    from zope.interface import implements
+    from pyramid.interfaces import IMultiView
+    implements(IMultiView)
+
+    def __init__(self, *views, **attrs):
+        self.views = [(None, view, None) for view in views]
+        self.__request_attrs__ = attrs
+