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``.

4 files changed, 516 insertions, 63 deletions

diff --git a/repoze/bfg/tests/test_chameleon_genshi.py b/repoze/bfg/tests/test_chameleon_genshi.py
index 0f0fc88a1..5a31ca6fa 100644
--- a/repoze/bfg/tests/test_chameleon_genshi.py
+++ b/repoze/bfg/tests/test_chameleon_genshi.py
@@ -19,7 +19,7 @@ class Base(PlacelessSetup):
         here = os.path.abspath(os.path.dirname(__file__))
         return os.path.join(here, 'fixtures', name)
 
-class GenshiTemplateFactoryTests(unittest.TestCase, Base):
+class GenshiTemplateRendererTests(unittest.TestCase, Base):
     def setUp(self):
         Base.setUp(self)
 
@@ -27,8 +27,8 @@ class GenshiTemplateFactoryTests(unittest.TestCase, Base):
         Base.tearDown(self)
 
     def _getTargetClass(self):
-        from repoze.bfg.chameleon_genshi import GenshiTemplateFactory
-        return GenshiTemplateFactory
+        from repoze.bfg.chameleon_genshi import GenshiTemplateRenderer
+        return GenshiTemplateRenderer
 
     def _makeOne(self, *arg, **kw):
         klass = self._getTargetClass()
@@ -36,14 +36,14 @@ class GenshiTemplateFactoryTests(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.genshi')
-        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,14 @@ class GenshiTemplateFactoryTests(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.genshi')
+        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)
@@ -92,6 +100,61 @@ 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_genshi 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_genshi import GenshiTemplateRenderer
+        from repoze.bfg.interfaces import ITemplateRenderer
+        minimal = self._getTemplatePath('minimal.genshi')
+        utility = GenshiTemplateRenderer(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_genshi import GenshiTemplateRenderer
+        from repoze.bfg.interfaces import ITemplateRenderer
+        minimal = self._getTemplatePath('minimal.genshi')
+        self.assertEqual(queryUtility(ITemplateRenderer, minimal), None)
+        utility = GenshiTemplateRenderer(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)
@@ -106,29 +169,42 @@ class GetTemplateTests(unittest.TestCase, Base):
     def test_nonabs_registered(self):
         from zope.component import getGlobalSiteManager
         from zope.component import queryUtility
-        from repoze.bfg.chameleon_genshi import GenshiTemplateFactory
-        from repoze.bfg.interfaces import ITemplate
+        from repoze.bfg.chameleon_genshi import GenshiTemplateRenderer
+        from repoze.bfg.interfaces import ITemplateRenderer
         minimal = self._getTemplatePath('minimal.genshi')
-        utility = GenshiTemplateFactory(minimal)
+        utility = GenshiTemplateRenderer(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):
         from zope.component import getGlobalSiteManager
         from zope.component import queryUtility
-        from repoze.bfg.chameleon_genshi import GenshiTemplateFactory
-        from repoze.bfg.interfaces import ITemplate
+        from repoze.bfg.chameleon_genshi import GenshiTemplateRenderer
+        from repoze.bfg.interfaces import ITemplateRenderer
         minimal = self._getTemplatePath('minimal.genshi')
-        self.assertEqual(queryUtility(ITemplate, minimal), None)
-        utility = GenshiTemplateFactory(minimal)
+        self.assertEqual(queryUtility(ITemplateRenderer, minimal), None)
+        utility = GenshiTemplateRenderer(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)
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)
+        
+        
+        
 
 
diff --git a/repoze/bfg/tests/test_testing.py b/repoze/bfg/tests/test_testing.py
new file mode 100644
index 000000000..23fbb7cc7
--- /dev/null
+++ b/repoze/bfg/tests/test_testing.py
@@ -0,0 +1,297 @@
+from zope.component.testing import PlacelessSetup
+import unittest
+
+class TestBFGTestCase(unittest.TestCase, PlacelessSetup):
+    def setUp(self):
+        PlacelessSetup.setUp(self)
+
+    def tearDown(self):
+        PlacelessSetup.tearDown(self)
+
+    def _getTargetClass(self):
+        from repoze.bfg.testing import BFGTestCase
+        return BFGTestCase
+
+    def _makeOne(self):
+        return self._getTargetClass()(methodName='__doc__')
+
+    def test_registerSecurityPolicy_permissive(self):
+        case = self._makeOne()
+        case.registerSecurityPolicy('user', ('group1', 'group2'),
+                                    permissive=True)
+        from repoze.bfg.interfaces import ISecurityPolicy
+        from zope.component import getUtility
+        ut = getUtility(ISecurityPolicy)
+        from repoze.bfg.testing import DummyAllowingSecurityPolicy
+        self.failUnless(isinstance(ut, DummyAllowingSecurityPolicy))
+        self.assertEqual(ut.userid, 'user')
+        self.assertEqual(ut.groupids, ('group1', 'group2'))
+        
+    def test_registerSecurityPolicy_nonpermissive(self):
+        case = self._makeOne()
+        case.registerSecurityPolicy('user', ('group1', 'group2'),
+                                    permissive=False)
+        from repoze.bfg.interfaces import ISecurityPolicy
+        from zope.component import getUtility
+        ut = getUtility(ISecurityPolicy)
+        from repoze.bfg.testing import DummyDenyingSecurityPolicy
+        self.failUnless(isinstance(ut, DummyDenyingSecurityPolicy))
+        self.assertEqual(ut.userid, 'user')
+        self.assertEqual(ut.groupids, ('group1', 'group2'))
+
+    def test_registerModels(self):
+        ob1 = object()
+        ob2 = object()
+        models = {'/ob1':ob1, '/ob2':ob2}
+        case = self._makeOne()
+        case.registerModels(models)
+        from zope.component import getAdapter
+        from repoze.bfg.interfaces import ITraverserFactory
+        adapter = getAdapter(None, ITraverserFactory)
+        self.assertEqual(adapter({'PATH_INFO':'/ob1'}), (ob1, '', []))
+        self.assertEqual(adapter({'PATH_INFO':'/ob2'}), (ob2, '', []))
+        self.assertRaises(KeyError, adapter, {'PATH_INFO':'/ob3'})
+        from repoze.bfg.traversal import find_model
+        self.assertEqual(find_model(None, '/ob1'), ob1)
+
+    def test_registerTemplate(self):
+        case = self._makeOne()
+        template = case.registerTemplate('templates/foo')
+        from repoze.bfg.testing import DummyTemplateRenderer
+        self.failUnless(isinstance(template, DummyTemplateRenderer))
+        from repoze.bfg.chameleon_zpt import render_template_to_response
+        response = render_template_to_response('templates/foo', foo=1, bar=2)
+        self.assertEqual(template.foo, 1)
+        self.assertEqual(template.bar, 2)
+        self.assertEqual(response.body, '')
+
+    def test_registerEventListener_single(self):
+        case = self._makeOne()
+        from zope.interface import implements
+        from zope.interface import Interface
+        class IEvent(Interface):
+            pass
+        class Event:
+            implements(IEvent)
+        L = case.registerEventListener(IEvent)
+        from zope.component.event import dispatch
+        event = Event()
+        dispatch(event)
+        self.assertEqual(len(L), 1)
+        self.assertEqual(L[0], event)
+        dispatch(object())
+        self.assertEqual(len(L), 1)
+        
+    def test_registerEventListener_defaults(self):
+        case = self._makeOne()
+        L = case.registerEventListener()
+        from zope.component.event import dispatch
+        event = object()
+        dispatch(event)
+        self.assertEqual(len(L), 2)
+        self.assertEqual(L[1], event)
+        dispatch(object())
+        self.assertEqual(len(L), 3)
+
+    def test_registerView_defaults(self):
+        case = self._makeOne()
+        view = case.registerView('moo.html')
+        import types
+        self.failUnless(isinstance(view, types.FunctionType))
+        from repoze.bfg.view import render_view_to_response
+        response = render_view_to_response(None, None, 'moo.html')
+        self.assertEqual(view(None, None).body, response.body)
+        
+    def test_registerView_withresult(self):
+        case = self._makeOne()
+        view = case.registerView('moo.html', 'yo')
+        import types
+        self.failUnless(isinstance(view, types.FunctionType))
+        from repoze.bfg.view import render_view_to_response
+        response = render_view_to_response(None, None, 'moo.html')
+        self.assertEqual(response.body, 'yo')
+
+    def test_registerView_custom(self):
+        case = self._makeOne()
+        def view(context, request):
+            from webob import Response
+            return Response('123')
+        view = case.registerView('moo.html', view=view)
+        import types
+        self.failUnless(isinstance(view, types.FunctionType))
+        from repoze.bfg.view import render_view_to_response
+        response = render_view_to_response(None, None, 'moo.html')
+        self.assertEqual(response.body, '123')
+
+    def test_registerViewPermission_defaults(self):
+        case = self._makeOne()
+        view = case.registerViewPermission('moo.html')
+        from repoze.bfg.view import view_execution_permitted
+        case.registerSecurityPolicy()
+        result = view_execution_permitted(None, None, 'moo.html')
+        self.failUnless(result)
+        self.assertEqual(result.msg, 'message')
+        
+    def test_registerViewPermission_denying(self):
+        case = self._makeOne()
+        view = case.registerViewPermission('moo.html', result=False)
+        from repoze.bfg.view import view_execution_permitted
+        case.registerSecurityPolicy()
+        result = view_execution_permitted(None, None, 'moo.html')
+        self.failIf(result)
+        self.assertEqual(result.msg, 'message')
+
+    def test_registerViewPermission_custom(self):
+        class ViewPermission:
+            def __init__(self, context, request):
+                self.context = context
+                self.request = request
+
+            def __call__(self, secpol):
+                return True
+                
+        case = self._makeOne()
+        view = case.registerViewPermission('moo.html',
+                                           viewpermission=ViewPermission)
+        from repoze.bfg.view import view_execution_permitted
+        case.registerSecurityPolicy()
+        result = view_execution_permitted(None, None, 'moo.html')
+        self.failUnless(result is True)
+
+    def test_registerAdapter(self):
+        from zope.interface import implements
+        from zope.interface import Interface
+        from zope.component import getMultiAdapter
+        class provides(Interface):
+            pass
+        class Provider:
+            implements(provides)
+            def __init__(self, context, request):
+                self.context = context
+                self.request = request
+        class for_(Interface):
+            pass
+        class For_:
+            implements(for_)
+        for1 = For_()
+        for2 = For_()
+        case = self._makeOne()
+        case.registerAdapter(Provider, (for_, for_), provides, name='foo')
+        adapter = getMultiAdapter((for1, for2), provides, name='foo')
+        self.failUnless(isinstance(adapter, Provider))
+        self.assertEqual(adapter.context, for1)
+        self.assertEqual(adapter.request, for2)
+
+    def test_registerUtility(self):
+        from zope.interface import implements
+        from zope.interface import Interface
+        from zope.component import getUtility
+        class iface(Interface):
+            pass
+        class impl:
+            implements(iface)
+            def __call__(self):
+                return 'foo'
+        case = self._makeOne()
+        utility = impl()
+        case.registerUtility(utility, iface, name='mudge')
+        self.assertEqual(getUtility(iface, name='mudge')(), 'foo')
+
+    def test_makeModel(self):
+        case = self._makeOne()
+        parent = object()
+        model = case.makeModel('name', parent)
+        self.assertEqual(model.__name__, 'name')
+        self.assertEqual(model.__parent__, parent)
+
+class TestDummyAllowingSecurityPolicy(unittest.TestCase):
+    def _getTargetClass(self):
+        from repoze.bfg.testing import DummyAllowingSecurityPolicy
+        return DummyAllowingSecurityPolicy
+
+    def _makeOne(self, userid=None, groupids=()):
+        klass = self._getTargetClass()
+        return klass(userid, groupids)
+
+    def test_authenticated_userid(self):
+        policy = self._makeOne('user')
+        self.assertEqual(policy.authenticated_userid(None), 'user')
+        
+    def test_effective_principals_userid(self):
+        policy = self._makeOne('user', ('group1',))
+        from repoze.bfg.security import Everyone
+        from repoze.bfg.security import Authenticated
+        self.assertEqual(policy.effective_principals(None),
+                         [Everyone, Authenticated, 'user', 'group1'])
+
+    def test_effective_principals_nouserid(self):
+        policy = self._makeOne()
+        from repoze.bfg.security import Everyone
+        self.assertEqual(policy.effective_principals(None), [Everyone])
+
+    def test_permits(self):
+        policy = self._makeOne()
+        self.assertEqual(policy.permits(None, None, None), True)
+        
+    def test_principals_allowed_by_permission(self):
+        policy = self._makeOne('user', ('group1',))
+        from repoze.bfg.security import Everyone
+        from repoze.bfg.security import Authenticated
+        self.assertEqual(policy.principals_allowed_by_permission(None, None),
+                         [Everyone, Authenticated, 'user', 'group1'])
+        
+
+class TestDummyDenyingSecurityPolicy(unittest.TestCase):
+    def _getTargetClass(self):
+        from repoze.bfg.testing import DummyDenyingSecurityPolicy
+        return DummyDenyingSecurityPolicy
+
+    def _makeOne(self, userid=None, groupids=()):
+        klass = self._getTargetClass()
+        return klass(userid, groupids)
+
+    def test_authenticated_userid(self):
+        policy = self._makeOne('user')
+        self.assertEqual(policy.authenticated_userid(None), 'user')
+        
+    def test_effective_principals_userid(self):
+        policy = self._makeOne('user', ('group1',))
+        from repoze.bfg.security import Everyone
+        from repoze.bfg.security import Authenticated
+        self.assertEqual(policy.effective_principals(None),
+                         [Everyone, Authenticated, 'user', 'group1'])
+
+    def test_effective_principals_nouserid(self):
+        policy = self._makeOne()
+        from repoze.bfg.security import Everyone
+        self.assertEqual(policy.effective_principals(None), [Everyone])
+
+    def test_permits(self):
+        policy = self._makeOne()
+        self.assertEqual(policy.permits(None, None, None), False)
+        
+    def test_principals_allowed_by_permission(self):
+        policy = self._makeOne('user', ('group1',))
+        self.assertEqual(policy.principals_allowed_by_permission(None, None),
+                         [])
+        
+class TestDummyModel(unittest.TestCase):
+    def _getTargetClass(self):
+        from repoze.bfg.testing import DummyModel
+        return DummyModel
+
+    def _makeOne(self, name=None, parent=None):
+        klass = self._getTargetClass()
+        return klass(name, parent)
+
+    def test__setitem__and__getitem__(self):
+        class Dummy:
+            pass
+        dummy = Dummy()
+        model = self._makeOne()
+        model['abc'] = dummy
+        self.assertEqual(dummy.__name__, 'abc')
+        self.assertEqual(dummy.__parent__, model)
+        self.assertEqual(model['abc'], dummy)
+        self.assertRaises(KeyError, model.__getitem__, 'none')
+
diff --git a/repoze/bfg/tests/test_xslt.py b/repoze/bfg/tests/test_xslt.py
index 0a858e08b..66e268331 100644
--- a/repoze/bfg/tests/test_xslt.py
+++ b/repoze/bfg/tests/test_xslt.py
@@ -19,7 +19,7 @@ class Base(PlacelessSetup):
         here = os.path.abspath(os.path.dirname(__file__))
         return os.path.join(here, 'fixtures', name)
         
-class XSLTemplateFactoryTests(unittest.TestCase, Base):
+class XSLTemplateRendererTests(unittest.TestCase, Base):
     def setUp(self):
         Base.setUp(self)
 
@@ -27,8 +27,8 @@ class XSLTemplateFactoryTests(unittest.TestCase, Base):
         Base.tearDown(self)
 
     def _getTargetClass(self):
-        from repoze.bfg.xslt import XSLTemplateFactory
-        return XSLTemplateFactory
+        from repoze.bfg.xslt import XSLTemplateRenderer
+        return XSLTemplateRenderer
 
     def _makeOne(self, *arg, **kw):
         klass = self._getTargetClass()
@@ -36,14 +36,14 @@ class XSLTemplateFactoryTests(unittest.TestCase, Base):
 
     def test_instance_implements_INodeTemplate(self):
         from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import INodeTemplate
+        from repoze.bfg.interfaces import INodeTemplateRenderer
         path = self._getTemplatePath('minimal.xsl')
-        verifyObject(INodeTemplate, self._makeOne(path))
+        verifyObject(INodeTemplateRenderer, self._makeOne(path))
 
     def test_class_implements_INodeTemplate(self):
         from zope.interface.verify import verifyClass
-        from repoze.bfg.interfaces import INodeTemplate
-        verifyClass(INodeTemplate, self._getTargetClass())
+        from repoze.bfg.interfaces import INodeTemplateRenderer
+        verifyClass(INodeTemplateRenderer, self._getTargetClass())
 
     def test_call(self):
         self._zcmlConfigure()
@@ -70,9 +70,9 @@ class RenderTransformToResponseTests(unittest.TestCase, Base):
     def test_nonabs_unregistered(self):
         self._zcmlConfigure()
         from zope.component import queryUtility
-        from repoze.bfg.interfaces import INodeTemplate
+        from repoze.bfg.interfaces import INodeTemplateRenderer
         minimal = self._getTemplatePath('minimal.xsl')
-        self.assertEqual(queryUtility(INodeTemplate, minimal), None)
+        self.assertEqual(queryUtility(INodeTemplateRenderer, minimal), None)
         render = self._getFUT()
         from lxml import etree
         info = etree.Element("info")
@@ -83,20 +83,20 @@ class RenderTransformToResponseTests(unittest.TestCase, Base):
         self.assertEqual(result.app_iter, [resultstr])
         self.assertEqual(result.status, '200 OK')
         self.assertEqual(len(result.headerlist), 2)
-        from repoze.bfg.xslt import XSLTemplateFactory
-        self.failUnless(isinstance(queryUtility(INodeTemplate, minimal),
-                                   XSLTemplateFactory))
+        from repoze.bfg.xslt import XSLTemplateRenderer
+        self.failUnless(isinstance(queryUtility(INodeTemplateRenderer, minimal),
+                                   XSLTemplateRenderer))
 
     def test_nonabs_registered(self):
         self._zcmlConfigure()
         from zope.component import getGlobalSiteManager
         from zope.component import queryUtility
-        from repoze.bfg.xslt import XSLTemplateFactory
-        from repoze.bfg.interfaces import INodeTemplate
+        from repoze.bfg.xslt import XSLTemplateRenderer
+        from repoze.bfg.interfaces import INodeTemplateRenderer
         minimal = self._getTemplatePath('minimal.xsl')
-        utility = XSLTemplateFactory(minimal)
+        utility = XSLTemplateRenderer(minimal)
         gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, INodeTemplate, name=minimal)
+        gsm.registerUtility(utility, INodeTemplateRenderer, name=minimal)
         render = self._getFUT()
         from lxml import etree
         info = etree.Element("info")
@@ -107,7 +107,7 @@ class RenderTransformToResponseTests(unittest.TestCase, Base):
         self.assertEqual(result.app_iter, [resultstr])
         self.assertEqual(result.status, '200 OK')
         self.assertEqual(len(result.headerlist), 2)
-        self.assertEqual(queryUtility(INodeTemplate, minimal), utility)
+        self.assertEqual(queryUtility(INodeTemplateRenderer, minimal), utility)
 
 class RenderTransformTests(unittest.TestCase, Base):
     def setUp(self):
@@ -123,9 +123,9 @@ class RenderTransformTests(unittest.TestCase, Base):
     def test_nonabs_unregistered(self):
         self._zcmlConfigure()
         from zope.component import queryUtility
-        from repoze.bfg.interfaces import INodeTemplate
+        from repoze.bfg.interfaces import INodeTemplateRenderer
         minimal = self._getTemplatePath('minimal.xsl')
-        self.assertEqual(queryUtility(INodeTemplate, minimal), None)
+        self.assertEqual(queryUtility(INodeTemplateRenderer, minimal), None)
         render = self._getFUT()
         from lxml import etree
         info = etree.Element("info")
@@ -133,20 +133,20 @@ class RenderTransformTests(unittest.TestCase, Base):
         self.failUnless(isinstance(result, str))
         resultstr = """<?xml version="1.0"?>\n<div/>\n"""
         self.assertEqual(result, resultstr)
-        from repoze.bfg.xslt import XSLTemplateFactory
-        self.failUnless(isinstance(queryUtility(INodeTemplate, minimal),
-                                   XSLTemplateFactory))
+        from repoze.bfg.xslt import XSLTemplateRenderer
+        self.failUnless(isinstance(queryUtility(INodeTemplateRenderer, minimal),
+                                   XSLTemplateRenderer))
 
     def test_nonabs_registered(self):
         self._zcmlConfigure()
         from zope.component import getGlobalSiteManager
         from zope.component import queryUtility
-        from repoze.bfg.xslt import XSLTemplateFactory
-        from repoze.bfg.interfaces import INodeTemplate
+        from repoze.bfg.xslt import XSLTemplateRenderer
+        from repoze.bfg.interfaces import INodeTemplateRenderer
         minimal = self._getTemplatePath('minimal.xsl')
-        utility = XSLTemplateFactory(minimal)
+        utility = XSLTemplateRenderer(minimal)
         gsm = getGlobalSiteManager()
-        gsm.registerUtility(utility, INodeTemplate, name=minimal)
+        gsm.registerUtility(utility, INodeTemplateRenderer, name=minimal)
         render = self._getFUT()
         from lxml import etree
         info = etree.Element("info")
@@ -154,5 +154,5 @@ class RenderTransformTests(unittest.TestCase, Base):
         self.failUnless(isinstance(result, str))
         resultstr = """<?xml version="1.0"?>\n<div/>\n"""
         self.assertEqual(result, resultstr)
-        self.assertEqual(queryUtility(INodeTemplate, minimal), utility)
+        self.assertEqual(queryUtility(INodeTemplateRenderer, minimal), utility)