Features

  - Added a ``repoze.bfg.testing`` module to attempt to make it
    slightly easier to write unittest-based automated tests of BFG
    applications.  Information about this class is in the
    documentation.

  - The default template renderer now supports testing better by
    looking for ``ITestingTemplateRenderer`` using a relative
    pathname.  This is exposed indirectly through the API named
    ``registerTemplate`` in ``repoze.bfg.testing``.

  Deprecations

  - The names ``repoze.bfg.interfaces.ITemplate`` ,
    ``repoze.bfg.interfaces.ITemplateFactory`` and
    ``repoze.bfg.interfaces.INodeTemplate`` have been deprecated.
    These should now be imported as
    ``repoze.bfg.interfaces.ITemplateRenderer`` and
    ``repoze.bfg.interfaces.ITemplateRendererFactory``, and
    ``INodeTemplateRenderer`` respectively.

  - The name ``repoze.bfg.chameleon_zpt.ZPTTemplateFactory`` is
    deprecated.  Use ``repoze.bfg.chameleon_zpt.ZPTTemplateRenderer``.

  - The name ``repoze.bfg.chameleon_genshi.GenshiTemplateFactory`` is
    deprecated.  Use
    ``repoze.bfg.chameleon_genshi.GenshiTemplateRenderer``.

  - The name ``repoze.bfg.xslt.XSLTemplateFactory`` is deprecated.
    Use ``repoze.bfg.xslt.XSLTemplateRenderer``.

1 files changed, 98 insertions, 18 deletions

diff --git a/repoze/bfg/tests/test_chameleon_zpt.py b/repoze/bfg/tests/test_chameleon_zpt.py
index 3b977bcbf..3ec956217 100644
--- a/repoze/bfg/tests/test_chameleon_zpt.py
+++ b/repoze/bfg/tests/test_chameleon_zpt.py
@@ -19,7 +19,7 @@ class Base(PlacelessSetup):
         here = os.path.abspath(os.path.dirname(__file__))
         return os.path.join(here, 'fixtures', name)
         
-class ZPTTemplateFactoryTests(unittest.TestCase, Base):
+class ZPTTemplateRendererTests(unittest.TestCase, Base):
     def setUp(self):
         Base.setUp(self)
 
@@ -27,8 +27,8 @@ class ZPTTemplateFactoryTests(unittest.TestCase, Base):
         Base.tearDown(self)
 
     def _getTargetClass(self):
-        from repoze.bfg.chameleon_zpt import ZPTTemplateFactory
-        return ZPTTemplateFactory
+        from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer
+        return ZPTTemplateRenderer
 
     def _makeOne(self, *arg, **kw):
         klass = self._getTargetClass()
@@ -36,14 +36,14 @@ class ZPTTemplateFactoryTests(unittest.TestCase, Base):
 
     def test_instance_implements_ITemplate(self):
         from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import ITemplate
+        from repoze.bfg.interfaces import ITemplateRenderer
         path = self._getTemplatePath('minimal.pt')
-        verifyObject(ITemplate, self._makeOne(path))
+        verifyObject(ITemplateRenderer, self._makeOne(path))
 
     def test_class_implements_ITemplate(self):
         from zope.interface.verify import verifyClass
-        from repoze.bfg.interfaces import ITemplate
-        verifyClass(ITemplate, self._getTargetClass())
+        from repoze.bfg.interfaces import ITemplateRenderer
+        verifyClass(ITemplateRenderer, self._getTargetClass())
 
     def test_call(self):
         self._zcmlConfigure()
@@ -53,6 +53,15 @@ class ZPTTemplateFactoryTests(unittest.TestCase, Base):
         self.failUnless(isinstance(result, str))
         self.assertEqual(result, '<div>\n</div>\n')
 
+    def test_implementation(self):
+        self._zcmlConfigure()
+        minimal = self._getTemplatePath('minimal.pt')
+        instance = self._makeOne(minimal)
+        result = instance.implementation()()
+        self.failUnless(isinstance(result, str))
+        self.assertEqual(result, '<div>\n</div>\n')
+        
+
 class RenderTemplateTests(unittest.TestCase, Base):
     def setUp(self):
         Base.setUp(self)
@@ -94,6 +103,60 @@ class RenderTemplateToResponseTests(unittest.TestCase, Base):
         self.assertEqual(result.status, '200 OK')
         self.assertEqual(len(result.headerlist), 2)
 
+class GetRendererTests(unittest.TestCase, Base):
+    def setUp(self):
+        Base.setUp(self)
+
+    def tearDown(self):
+        Base.tearDown(self)
+
+    def _getFUT(self):
+        from repoze.bfg.chameleon_zpt import get_renderer
+        return get_renderer
+
+    def test_nonabs_registered(self):
+        from zope.component import getGlobalSiteManager
+        from zope.component import queryUtility
+        from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer
+        from repoze.bfg.interfaces import ITemplateRenderer
+        minimal = self._getTemplatePath('minimal.pt')
+        utility = ZPTTemplateRenderer(minimal)
+        gsm = getGlobalSiteManager()
+        gsm.registerUtility(utility, ITemplateRenderer, name=minimal)
+        get = self._getFUT()
+        result = get(minimal)
+        self.assertEqual(result, utility)
+        self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility)
+        
+    def test_nonabs_unregistered(self):
+        from zope.component import getGlobalSiteManager
+        from zope.component import queryUtility
+        from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer
+        from repoze.bfg.interfaces import ITemplateRenderer
+        minimal = self._getTemplatePath('minimal.pt')
+        self.assertEqual(queryUtility(ITemplateRenderer, minimal), None)
+        utility = ZPTTemplateRenderer(minimal)
+        gsm = getGlobalSiteManager()
+        gsm.registerUtility(utility, ITemplateRenderer, name=minimal)
+        get = self._getFUT()
+        result = get(minimal)
+        self.assertEqual(result, utility)
+        self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility)
+
+    def test_testing(self):
+        from zope.component import getGlobalSiteManager
+        from repoze.bfg.interfaces import ITestingTemplateRenderer
+        class Dummy:
+            template = object()
+            def implementation(self):
+                return self.template
+        gsm = getGlobalSiteManager()
+        utility = Dummy()
+        gsm.registerUtility(utility, ITestingTemplateRenderer, name='foo')
+        get = self._getFUT()
+        result = get('foo')
+        self.failUnless(result is utility)
+
 class GetTemplateTests(unittest.TestCase, Base):
     def setUp(self):
         Base.setUp(self)
@@ -109,31 +172,48 @@ class GetTemplateTests(unittest.TestCase, Base):
         self._zcmlConfigure()
         from zope.component import getGlobalSiteManager
         from zope.component import queryUtility
-        from repoze.bfg.chameleon_zpt import ZPTTemplateFactory
-        from repoze.bfg.interfaces import ITemplate
+        from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer
+        from repoze.bfg.interfaces import ITemplateRenderer
         minimal = self._getTemplatePath('minimal.pt')
-        utility = ZPTTemplateFactory(minimal)
+        utility = ZPTTemplateRenderer(minimal)
         gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, ITemplate, name=minimal)
+        gsm.registerUtility(utility, ITemplateRenderer, name=minimal)
         get = self._getFUT()
         result = get(minimal)
         self.assertEqual(result.filename, minimal)
-        self.assertEqual(queryUtility(ITemplate, minimal), utility)
+        self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility)
         
     def test_nonabs_unregistered(self):
         self._zcmlConfigure()
         from zope.component import getGlobalSiteManager
         from zope.component import queryUtility
-        from repoze.bfg.chameleon_zpt import ZPTTemplateFactory
-        from repoze.bfg.interfaces import ITemplate
+        from repoze.bfg.chameleon_zpt import ZPTTemplateRenderer
+        from repoze.bfg.interfaces import ITemplateRenderer
         minimal = self._getTemplatePath('minimal.pt')
-        self.assertEqual(queryUtility(ITemplate, minimal), None)
-        utility = ZPTTemplateFactory(minimal)
+        self.assertEqual(queryUtility(ITemplateRenderer, minimal), None)
+        utility = ZPTTemplateRenderer(minimal)
         gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, ITemplate, name=minimal)
+        gsm.registerUtility(utility, ITemplateRenderer, name=minimal)
         get = self._getFUT()
         result = get(minimal)
         self.assertEqual(result.filename, minimal)
-        self.assertEqual(queryUtility(ITemplate, minimal), utility)
+        self.assertEqual(queryUtility(ITemplateRenderer, minimal), utility)
+
+    def test_testing(self):
+        from zope.component import getGlobalSiteManager
+        from repoze.bfg.interfaces import ITestingTemplateRenderer
+        class Dummy:
+            template = object()
+            def implementation(self):
+                return self.template
+        gsm = getGlobalSiteManager()
+        utility = Dummy()
+        gsm.registerUtility(utility, ITestingTemplateRenderer, name='foo')
+        get = self._getFUT()
+        result = get('foo')
+        self.failUnless(result is utility.template)
+        
+        
+