From deb0dc316b64d5fb7bd0e15a1bafe269d3b33fbc Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Fri, 7 Nov 2008 10:47:28 +0000 Subject: 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``. --- repoze/bfg/tests/test_testing.py | 297 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 297 insertions(+) create mode 100644 repoze/bfg/tests/test_testing.py (limited to 'repoze/bfg/tests/test_testing.py') 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') + -- cgit v1.2.3