And, just to maximally confuse Paul, come full circle, and don't require that the template be spelled on the class, while still allowing us to pickle the registry actions.

1 files changed, 77 insertions, 7 deletions

diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index 11f392f78..7aaf6e4c3 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -100,34 +100,104 @@ class TestViewDirective(unittest.TestCase, PlacelessSetup):
         self.assertEqual(regadapt['args'][4], '')
         self.assertEqual(regadapt['args'][5], None)
 
-    def test_template_and_factory_raises(self):
+    def test_template_and_factory(self):
         f = self._getFUT()
         context = DummyContext()
-        from zope.configuration.exceptions import ConfigurationError
-        self.assertRaises(ConfigurationError, f, context, 'repoze.view', None,
-                          Dummy, 'minimal.html', 'minimal.pt')
+        class IFoo:
+            pass
+        class DummyView:
+            pass
+        f(context, 'repoze.view', IFoo, factory=DummyView,
+          template='minimal.pt')
+        actions = context.actions
+        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IViewFactory
+        from zope.component.zcml import handler
+        from zope.component.interface import provideInterface
+
+        self.assertEqual(len(actions), 3)
+
+        regutil_discriminator = ('utility', IView, context.path('minimal.pt'))
+        regutil = actions[0]
+        self.assertEqual(regutil['discriminator'], regutil_discriminator)
+        self.assertEqual(regutil['callable'], handler)
+        self.assertEqual(regutil['args'][0], 'registerUtility')
+        self.assertEqual(regutil['args'][1].template.filename,
+                         context.path('minimal.pt'))
+        self.assertEqual(regutil['args'][2], IView)
+        self.assertEqual(regutil['args'][3], context.path('minimal.pt'))
+
+        provide = actions[1]
+        self.assertEqual(provide['discriminator'], None)
+        self.assertEqual(provide['callable'], provideInterface)
+        self.assertEqual(provide['args'][0], '')
+        self.assertEqual(provide['args'][1], IFoo)
+        
+        regadapt = actions[2]
+        regadapt_discriminator = ('view', IFoo, '', IRequest, IViewFactory)
+        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
+        self.assertEqual(regadapt['callable'], handler)
+        self.assertEqual(regadapt['args'][0], 'registerAdapter')
+        self.assertEqual(regadapt['args'][1].template,
+                         context.path('minimal.pt'))
+        self.assertEqual(regadapt['args'][2], (IFoo, IRequest))
+        self.assertEqual(regadapt['args'][3], IViewFactory)
+        self.assertEqual(regadapt['args'][4], '')
+        self.assertEqual(regadapt['args'][5], None)
 
 class TestTemplateViewFactory(unittest.TestCase):
     def _getTargetClass(self):
         from repoze.bfg.zcml import TemplateViewFactory
         return TemplateViewFactory
 
-    def _makeOne(self, template):
-        return self._getTargetClass()(template)
+    def _makeOne(self, template, base=None):
+        return self._getTargetClass()(template, base)
 
     def test_instance_conforms_to_IViewFactory(self):
         from zope.interface.verify import verifyObject
         from repoze.bfg.interfaces import IViewFactory
         verifyObject(IViewFactory, self._makeOne('a'))
 
-    def test_call(self):
+    def test_call_templateonly(self):
         context = DummyContext()
         template = context.path('minimal.pt')
         factory = self._makeOne(template)
         view = factory(None, None)
         from repoze.bfg.view import TemplateView
         self.failUnless(isinstance(view, TemplateView))
+        self.assertEqual(view.template, template)
         
+    def test_call_nonclassbase(self):
+        context = DummyContext()
+        def factory():
+            pass
+        template = context.path('minimal.pt')
+        self.assertRaises(ValueError, self._makeOne, template, factory)
+
+    def test_call_classbase_not_templateview_subclass(self):
+        context = DummyContext()
+        template = context.path('minimal.pt')
+        factory = self._makeOne(template, Dummy)
+        view = factory(None, None)
+        from repoze.bfg.view import TemplateView
+        self.assertEqual(view.__bases__[0], Dummy)
+        self.assertEqual(view.__bases__[1], TemplateView)
+        self.assertEqual(view.__name__, 'DynamicTemplateView_For_Dummy')
+        self.assertEqual(view.template, template)
+
+    def test_call_classbase_templateview_subclass(self):
+        context = DummyContext()
+        template = context.path('minimal.pt')
+        from repoze.bfg.view import TemplateView
+        class TemplateViewSubclass(TemplateView):
+            pass
+        factory = self._makeOne(template, TemplateViewSubclass)
+        view = factory(None, None)
+        self.assertEqual(view.__bases__[0], TemplateViewSubclass)
+        self.assertEqual(view.__name__,
+                         'DynamicTemplateView_For_TemplateViewSubclass')
+        self.assertEqual(view.template, template)
 
 class Dummy:
     pass