From a7a6d7568546dcc88d836653cce8e69916f1e442 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Fri, 1 May 2009 08:02:55 +0000 Subject: - The ``repoze.bfg.location.LocationProxy`` class and the ``repoze.bfg.location.ClassAndInstanceDescr`` class have both been removed in order to be able to eventually shed a dependency on ``zope.proxy``. Neither of these classes was ever an API. - In all previous releases, the ``repoze.bfg.location.locate`` function worked like so: if a model did not explicitly provide the ``repoze.bfg.interfaces.ILocation`` interface, ``locate`` returned a ``LocationProxy`` object representing ``model`` with its ``__parent__`` attribute assigned to ``parent`` and a ``__name__`` attribute assigned to ``__name__``. In this release, the ``repoze.bfg.location.locate`` function simply jams the ``__name__`` and ``__parent__`` attributes on to the supplied model unconditionally, no matter if the object implements ILocation or not, and it never returns a proxy. This was done because the LocationProxy behavior has now moved into an add-on package (``repoze.bfg.traversalwrapper``), in order to eventually be able to shed a dependency on ``zope.proxy``. - In all previous releases, by default, if traversal was used (as opposed to URL-dispatch), and the root object supplied the``repoze.bfg.interfaces.ILocation`` interface, but the children returned via its ``__getitem__`` returned an object that did not implement the same interface, :mod:`repoze.bfg` provided some implicit help during traversal. This traversal feature wrapped subobjects from the root (and thereafter) that did not implement ``ILocation`` in proxies which automatically provided them with a ``__name__`` and ``__parent__`` attribute based on the name being traversed and the previous object traversed. This feature has now been removed from the base ``repoze.bfg`` package for purposes of eventually shedding a dependency on ``zope.proxy``. In order to re-enable the wrapper behavior for older applications which cannot be changed, register the "traversalwrapper" ``ModelGraphTraverser`` as the traversal policy, rather than the default ``ModelGraphTraverser``. To use this feature, you will need to install the ``repoze.bfg.traversalwrapper`` package (an add-on package, available at http://svn.repoze.org/repoze.bfg.traversalwrapper) Then change your application's ``configure.zcml`` to include the following stanza: When this ITraverserFactory is used instead of the default, no object in the graph (even the root object) must supply a ``__name__`` or ``__parent__`` attribute. Even if subobjects returned from the root *do* implement the ILocation interface, these will still be wrapped in proxies that override the object's "real" ``__parent__`` and ``__name__`` attributes. See also changes to the "Models" chapter of the documentation (in the "Location-Aware Model Instances") section. --- repoze/bfg/tests/test_location.py | 58 -------------------------------------- repoze/bfg/tests/test_traversal.py | 34 ---------------------- 2 files changed, 92 deletions(-) (limited to 'repoze/bfg/tests') diff --git a/repoze/bfg/tests/test_location.py b/repoze/bfg/tests/test_location.py index f297a9d6c..9de059a86 100644 --- a/repoze/bfg/tests/test_location.py +++ b/repoze/bfg/tests/test_location.py @@ -17,8 +17,6 @@ class TestLocation(unittest.TestCase): def test_locate(self): from repoze.bfg.location import locate - from repoze.bfg.location import LocationProxy - a = Location() parent = Location() a_located = locate(a, parent, 'a') @@ -30,40 +28,6 @@ class TestLocation(unittest.TestCase): a_located_2 = locate(a_located, parent, 'a') self.failUnless(a_located_2 is a_located) - # If the object does not provide ILocation a LocationProxy is returned: - - l = [1, 2, 3] - parent = Location() - l_located = locate(l, parent, 'l') - self.assertEqual(l_located, [1, 2, 3]) - self.failUnless(l_located.__parent__ is parent) - self.assertEqual(l_located.__name__, 'l') - self.failIf(l_located is l) - self.assertEqual(type(l_located), LocationProxy) - - l_located_2 = locate(l_located, parent, 'l') - self.failUnless(l_located_2 is l_located) - # When changing the name, we still do not get a different proxied - # object: - - l_located_3 = locate(l_located, parent, 'new-name') - self.failUnless(l_located_3 is l_located_2) - - def test_LocationProxy(self): - from repoze.bfg.location import LocationProxy - from repoze.bfg.interfaces import ILocation - l = [1, 2, 3] - self.assertEqual(ILocation.providedBy(l), False) - p = LocationProxy(l, "Dad", "p") - self.assertEqual(p, [1, 2, 3]) - self.assertEqual(ILocation.providedBy(p), True) - self.assertEqual(p.__parent__, 'Dad') - self.assertEqual(p.__name__, 'p') - import pickle - self.assertRaises(TypeError, pickle.dumps, p) - # Proxies should get their doc strings from the object they proxy: - self.assertEqual(p.__doc__, l.__doc__) - def test_lineage(self): from repoze.bfg.location import lineage o1 = Location() @@ -75,28 +39,6 @@ class TestLocation(unittest.TestCase): result = list(lineage(o1)) self.assertEqual(result, [o1]) -class TestClassAndInstanceDescr(unittest.TestCase): - def _getTargetClass(self): - from repoze.bfg.location import ClassAndInstanceDescr - return ClassAndInstanceDescr - - def _makeOne(self, *arg): - return self._getTargetClass()(*arg) - - def test__get__noinst(self): - def f(ob): - return ob - ob = self._makeOne(f, f) - result = ob.__get__(None, 1) - self.assertEqual(result, 1) - - def test__get__withinst(self): - def f(ob): - return ob - ob = self._makeOne(f, f) - result = ob.__get__(1, 2) - self.assertEqual(result, 1) - from repoze.bfg.interfaces import ILocation from zope.interface import implements class Location(object): diff --git a/repoze/bfg/tests/test_traversal.py b/repoze/bfg/tests/test_traversal.py index 942f84684..f361d0a79 100644 --- a/repoze/bfg/tests/test_traversal.py +++ b/repoze/bfg/tests/test_traversal.py @@ -189,40 +189,6 @@ class ModelGraphTraverserTests(unittest.TestCase): environ = self._getEnviron(PATH_INFO='/%s' % segment) self.assertRaises(TypeError, policy, environ) -class WrappingModelGraphTraverserTests(ModelGraphTraverserTests): - - def _getTargetClass(self): - from repoze.bfg.traversal import WrappingModelGraphTraverser - return WrappingModelGraphTraverser - - def test_call_proxies(self): - baz = DummyContext() - bar = DummyContext(baz) - foo = DummyContext(bar) - root = DummyContext(foo) - from zope.proxy import isProxy - policy = self._makeOne(root) - environ = self._getEnviron(PATH_INFO='/foo/bar/baz') - ctx, name, subpath, traversed, vroot, vroot_path = policy(environ) - self.assertEqual(name, '') - self.assertEqual(subpath, []) - self.assertEqual(ctx, baz) - self.failUnless(isProxy(ctx)) - self.assertEqual(ctx.__name__, 'baz') - self.assertEqual(ctx.__parent__, bar) - self.failUnless(isProxy(ctx.__parent__)) - self.assertEqual(ctx.__parent__.__name__, 'bar') - self.assertEqual(ctx.__parent__.__parent__, foo) - self.failUnless(isProxy(ctx.__parent__.__parent__)) - self.assertEqual(ctx.__parent__.__parent__.__name__, 'foo') - self.assertEqual(ctx.__parent__.__parent__.__parent__, root) - self.failUnless(isProxy(ctx.__parent__.__parent__.__parent__)) - self.assertEqual(ctx.__parent__.__parent__.__parent__.__name__, None) - self.assertEqual(ctx.__parent__.__parent__.__parent__.__parent__, None) - self.assertEqual(traversed, [u'foo', u'bar', u'baz']) - self.assertEqual(vroot, root) - self.assertEqual(vroot_path, []) - class FindInterfaceTests(unittest.TestCase): def _callFUT(self, context, iface): from repoze.bfg.traversal import find_interface -- cgit v1.2.3