- The ``repoze.bfg.view.rendered_response`` function has been moved to

  ``repoze.bfg.configuration.rendered_response``.

- The ``repoze.bfg.view.decorate_view`` function has been moved to
  ``repoze.bfg.configuration.decorate_view``.

- The ``repoze.bfg.view.MultiView`` class has been moved to
  ``repoze.bfg.configuration.MultiView``.

- Fix argument ordering bug in r.b.configuration.Configurator.resource.

1 files changed, 0 insertions, 442 deletions

diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py
index e06f6225f..c293394c1 100644
--- a/repoze/bfg/tests/test_view.py
+++ b/repoze/bfg/tests/test_view.py
@@ -526,86 +526,6 @@ class AppendSlashNotFoundView(unittest.TestCase):
         self.assertEqual(response.status, '302 Found')
         self.assertEqual(response.location, '/abc/')
 
-class Test_rendered_response(unittest.TestCase):
-    def setUp(self):
-        cleanUp()
-
-    def tearDown(self):
-        cleanUp()
-
-    def _callFUT(self, renderer, response, view=None,
-                 context=None, request=None, renderer_name=None):
-        from repoze.bfg.view import rendered_response
-        if request is None:
-            request = DummyRequest()
-        return rendered_response(renderer, response, view,
-                                 context, request, renderer_name)
-
-    def _makeRenderer(self):
-        def renderer(*arg):
-            return 'Hello!'
-        return renderer
-
-    def test_is_response(self):
-        renderer = self._makeRenderer()
-        response = DummyResponse()
-        result = self._callFUT(renderer, response)
-        self.assertEqual(result, response)
-
-    def test_calls_renderer(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        result = self._callFUT(renderer, response)
-        self.assertEqual(result.body, 'Hello!')
-
-    def test_with_content_type(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        request = DummyRequest()
-        attrs = {'response_content_type':'text/nonsense'}
-        request.__dict__.update(attrs)
-        result = self._callFUT(renderer, response, request=request)
-        self.assertEqual(result.content_type, 'text/nonsense')
-
-    def test_with_headerlist(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        request = DummyRequest()
-        attrs = {'response_headerlist':[('a', '1'), ('b', '2')]}
-        request.__dict__.update(attrs)
-        result = self._callFUT(renderer, response, request=request)
-        self.assertEqual(result.headerlist,
-                         [('Content-Type', 'text/html; charset=UTF-8'),
-                          ('Content-Length', '6'),
-                          ('a', '1'),
-                          ('b', '2')])
-
-    def test_with_status(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        request = DummyRequest()
-        attrs = {'response_status':'406 You Lose'}
-        request.__dict__.update(attrs)
-        result = self._callFUT(renderer, response, request=request)
-        self.assertEqual(result.status, '406 You Lose')
-
-    def test_with_charset(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        request = DummyRequest()
-        attrs = {'response_charset':'UTF-16'}
-        request.__dict__.update(attrs)
-        result = self._callFUT(renderer, response, request=request)
-        self.assertEqual(result.charset, 'UTF-16')
-
-    def test_with_cache_for(self):
-        renderer = self._makeRenderer()
-        response = {'a':'1'}
-        request = DummyRequest()
-        attrs = {'response_cache_for':100}
-        request.__dict__.update(attrs)
-        result = self._callFUT(renderer, response, request=request)
-        self.assertEqual(result.cache_control.max_age, 100)
 
 class TestDeriveView(unittest.TestCase):
     def setUp(self):
@@ -921,368 +841,6 @@ class TestDeriveView(unittest.TestCase):
             inner_view, viewname='inner', wrapper_viewname='owrap')
         result = self.assertRaises(ValueError, wrapped, None, request)
 
-class TestDecorateView(unittest.TestCase):
-    def _callFUT(self, wrapped, original):
-        from repoze.bfg.view import decorate_view
-        return decorate_view(wrapped, original)
-    
-    def test_it_same(self):
-        def view(context, request):
-            """ """
-        result = self._callFUT(view, view)
-        self.assertEqual(result, False)
-
-    def test_it_different(self):
-        class DummyView1:
-            """ 1 """
-            __name__ = '1'
-            __module__ = '1'
-            def __call__(self, context, request):
-                """ """
-            def __call_permissive__(self, context, reuqest):
-                """ """
-            def __predicated__(self, context, reuqest):
-                """ """
-            def __permitted__(self, context, request):
-                """ """
-        class DummyView2:
-            """ 2 """
-            __name__ = '2'
-            __module__ = '2'
-            def __call__(self, context, request):
-                """ """
-            def __call_permissive__(self, context, reuqest):
-                """ """
-            def __predicated__(self, context, reuqest):
-                """ """
-            def __permitted__(self, context, request):
-                """ """
-        view1 = DummyView1()
-        view2 = DummyView2()
-        result = self._callFUT(view1, view2)
-        self.assertEqual(result, True)
-        self.failUnless(view1.__doc__ is view2.__doc__)
-        self.failUnless(view1.__module__ is view2.__module__)
-        self.failUnless(view1.__name__ is view2.__name__)
-        self.failUnless(view1.__call_permissive__.im_func is
-                        view2.__call_permissive__.im_func)
-        self.failUnless(view1.__permitted__.im_func is
-                        view2.__permitted__.im_func)
-        self.failUnless(view1.__predicated__.im_func is
-                        view2.__predicated__.im_func)
-
-class TestMultiView(unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.view import MultiView
-        return MultiView
-
-    def _makeOne(self, name='name'):
-        return self._getTargetClass()(name)
-    
-    def test_class_implements_ISecuredView(self):
-        from zope.interface.verify import verifyClass
-        from repoze.bfg.interfaces import ISecuredView
-        verifyClass(ISecuredView, self._getTargetClass())
-
-    def test_instance_implements_ISecuredView(self):
-        from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import ISecuredView
-        verifyObject(ISecuredView, self._makeOne())
-
-    def test_add(self):
-        mv = self._makeOne()
-        mv.add('view', 100)
-        self.assertEqual(mv.views, [(100, 'view')])
-        mv.add('view2', 99)
-        self.assertEqual(mv.views, [(99, 'view2'), (100, 'view')])
-
-    def test_match_not_found(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertRaises(NotFound, mv.match, context, request)
-
-    def test_match_predicate_fails(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        def view(context, request):
-            """ """
-        view.__predicated__ = lambda *arg: False
-        mv.views = [(100, view)]
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertRaises(NotFound, mv.match, context, request)
-
-    def test_match_predicate_succeeds(self):
-        mv = self._makeOne()
-        def view(context, request):
-            """ """
-        view.__predicated__ = lambda *arg: True
-        mv.views = [(100, view)]
-        context = DummyContext()
-        request = DummyRequest()
-        result = mv.match(context, request)
-        self.assertEqual(result, view)
-
-    def test_permitted_no_views(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertRaises(NotFound, mv.__permitted__, context, request)
-
-    def test_permitted_no_match_with__permitted__(self):
-        mv = self._makeOne()
-        def view(context, request):
-            """ """
-        mv.views = [(100, view)]
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertEqual(mv.__permitted__(None, None), True)
-        
-    def test_permitted(self):
-        from zope.component import getSiteManager
-        mv = self._makeOne()
-        def view(context, request):
-            """ """
-        def permitted(context, request):
-            return False
-        view.__permitted__ = permitted
-        mv.views = [(100, view)]
-        context = DummyContext()
-        request = DummyRequest()
-        sm = getSiteManager()
-        result = mv.__permitted__(context, request)
-        self.assertEqual(result, False)
-
-    def test__call__not_found(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertRaises(NotFound, mv, context, request)
-
-    def test___call__intermediate_not_found(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        request.view_name = ''
-        expected_response = DummyResponse()
-        def view1(context, request):
-            raise NotFound
-        def view2(context, request):
-            return expected_response
-        mv.views = [(100, view1), (99, view2)]
-        response = mv(context, request)
-        self.assertEqual(response, expected_response)
-
-    def test___call__(self):
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        request.view_name = ''
-        expected_response = DummyResponse()
-        def view(context, request):
-            return expected_response
-        mv.views = [(100, view)]
-        response = mv(context, request)
-        self.assertEqual(response, expected_response)
-
-    def test__call_permissive__not_found(self):
-        from repoze.bfg.exceptions import NotFound
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        self.assertRaises(NotFound, mv, context, request)
-
-    def test___call_permissive_has_call_permissive(self):
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        request.view_name = ''
-        expected_response = DummyResponse()
-        def view(context, request):
-            """ """
-        def permissive(context, request):
-            return expected_response
-        view.__call_permissive__ = permissive
-        mv.views = [(100, view)]
-        response = mv.__call_permissive__(context, request)
-        self.assertEqual(response, expected_response)
-
-    def test___call_permissive_has_no_call_permissive(self):
-        mv = self._makeOne()
-        context = DummyContext()
-        request = DummyRequest()
-        request.view_name = ''
-        expected_response = DummyResponse()
-        def view(context, request):
-            return expected_response
-        mv.views = [(100, view)]
-        response = mv.__call_permissive__(context, request)
-        self.assertEqual(response, expected_response)
-
-class TestRequestOnly(unittest.TestCase):
-    def _callFUT(self, arg):
-        from repoze.bfg.view import requestonly
-        return requestonly(arg)
-    
-    def test_newstyle_class_no_init(self):
-        class foo(object):
-            """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_newstyle_class_init_toomanyargs(self):
-        class foo(object):
-            def __init__(self, context, request):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_newstyle_class_init_onearg_named_request(self):
-        class foo(object):
-            def __init__(self, request):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_newstyle_class_init_onearg_named_somethingelse(self):
-        class foo(object):
-            def __init__(self, req):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_newstyle_class_init_defaultargs_firstname_not_request(self):
-        class foo(object):
-            def __init__(self, context, request=None):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_newstyle_class_init_defaultargs_firstname_request(self):
-        class foo(object):
-            def __init__(self, request, foo=1, bar=2):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_newstyle_class_init_noargs(self):
-        class foo(object):
-            def __init__():
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_oldstyle_class_no_init(self):
-        class foo:
-            """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_oldstyle_class_init_toomanyargs(self):
-        class foo:
-            def __init__(self, context, request):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_oldstyle_class_init_onearg_named_request(self):
-        class foo:
-            def __init__(self, request):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_oldstyle_class_init_onearg_named_somethingelse(self):
-        class foo:
-            def __init__(self, req):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_oldstyle_class_init_defaultargs_firstname_not_request(self):
-        class foo:
-            def __init__(self, context, request=None):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_oldstyle_class_init_defaultargs_firstname_request(self):
-        class foo:
-            def __init__(self, request, foo=1, bar=2):
-                """ """
-        self.assertTrue(self._callFUT(foo), True)
-
-    def test_oldstyle_class_init_noargs(self):
-        class foo:
-            def __init__():
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_function_toomanyargs(self):
-        def foo(context, request):
-            """ """
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_function_onearg_named_request(self):
-        def foo(request):
-            """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_function_onearg_named_somethingelse(self):
-        def foo(req):
-            """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_function_defaultargs_firstname_not_request(self):
-        def foo(context, request=None):
-            """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_function_defaultargs_firstname_request(self):
-        def foo(request, foo=1, bar=2):
-            """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_function_noargs(self):
-        def foo():
-            """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_instance_toomanyargs(self):
-        class Foo:
-            def __call__(self, context, request):
-                """ """
-        foo = Foo()
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_instance_defaultargs_onearg_named_request(self):
-        class Foo:
-            def __call__(self, request):
-                """ """
-        foo = Foo()
-        self.assertTrue(self._callFUT(foo))
-
-    def test_instance_defaultargs_onearg_named_somethingelse(self):
-        class Foo:
-            def __call__(self, req):
-                """ """
-        foo = Foo()
-        self.assertTrue(self._callFUT(foo))
-
-    def test_instance_defaultargs_firstname_not_request(self):
-        class Foo:
-            def __call__(self, context, request=None):
-                """ """
-        foo = Foo()
-        self.assertFalse(self._callFUT(foo))
-
-    def test_instance_defaultargs_firstname_request(self):
-        class Foo:
-            def __call__(self, request, foo=1, bar=2):
-                """ """
-        foo = Foo()
-        self.assertTrue(self._callFUT(foo), True)
-
-    def test_instance_nocall(self):
-        class Foo: pass
-        foo = Foo()
-        self.assertFalse(self._callFUT(foo))
-
-
-
 class DummyContext:
     pass