Backwards Incompatibilities

---------------------------

- The ``repoze.bfg.traversal.model_path`` API now returns a tuple
  instead of a string.  Previously it returned a string representing
  the model path, with each segment name in the path joined together
  via ``/`` characters, e.g. ``/foo/bar``.  Now it returns a tuple,
  where each segment is an element in the tuple e.g. ``('', 'foo',
  'bar')`` (the leading empty element indicates that this path is
  absolute).  This change was (as discussed on the repoze-dev
  maillist) necessary to accomodate model objects which themselves
  have names that contain the ``/`` character.  See the API
  documentation for ``repoze.bfg.traversal.model_path`` for more
  information.

- The ``repoze.bfg.traversal.find_model`` API no longer implicitly
  converts unicode path representations into a UTF-8 string.  Callers
  should either use path tuples or use the guidelines about passing a
  string ``path`` argument described in its API documentation.

Features
--------

- The ``find_model`` API now accepts "path tuples" (see the above note
  regarding ``model_path``) as well as string path representations as
  a ``path`` argument.

1 files changed, 102 insertions, 43 deletions

diff --git a/repoze/bfg/tests/test_traversal.py b/repoze/bfg/tests/test_traversal.py
index 4782ab264..1486e5b91 100644
--- a/repoze/bfg/tests/test_traversal.py
+++ b/repoze/bfg/tests/test_traversal.py
@@ -279,63 +279,119 @@ class FindModelTests(unittest.TestCase):
         from zope.interface import Interface
         gsm.registerAdapter(traverser, (Interface,), ITraverserFactory)
 
-    def test_relative_found(self):
-        dummy = DummyContext()
+    def test_list(self):
+        model = DummyContext()
+        traverser = make_traverser(model, '', [])
+        self._registerTraverserFactory(traverser)
+        result = self._callFUT(model, [''])
+        self.assertEqual(result, model)
+        self.assertEqual(model.environ['PATH_INFO'], '/')
+
+    def test_generator(self):
+        model = DummyContext()
+        traverser = make_traverser(model, '', [])
+        self._registerTraverserFactory(traverser)
+        def foo():
+            yield ''
+        result = self._callFUT(model, foo())
+        self.assertEqual(result, model)
+        self.assertEqual(model.environ['PATH_INFO'], '/')
+
+    def test_self_string_found(self):
+        model = DummyContext()
+        traverser = make_traverser(model, '', [])
+        self._registerTraverserFactory(traverser)
+        result = self._callFUT(model, '')
+        self.assertEqual(result, model)
+        self.assertEqual(model.environ['PATH_INFO'], '')
+
+    def test_self_tuple_found(self):
+        model = DummyContext()
+        traverser = make_traverser(model, '', [])
+        self._registerTraverserFactory(traverser)
+        result = self._callFUT(model, ())
+        self.assertEqual(result, model)
+        self.assertEqual(model.environ['PATH_INFO'], '')
+
+    def test_relative_string_found(self):
+        model = DummyContext()
         baz = DummyContext()
         traverser = make_traverser(baz, '', [])
         self._registerTraverserFactory(traverser)
-        result = self._callFUT(dummy, 'baz')
+        result = self._callFUT(model, 'baz')
         self.assertEqual(result, baz)
+        self.assertEqual(model.environ['PATH_INFO'], 'baz')
 
-    def test_relative_notfound(self):
-        dummy = DummyContext()
+    def test_relative_tuple_found(self):
+        model = DummyContext()
         baz = DummyContext()
-        traverser = make_traverser(baz, 'bar', [])
+        traverser = make_traverser(baz, '', [])
         self._registerTraverserFactory(traverser)
-        self.assertRaises(KeyError, self._callFUT, dummy, 'baz')
+        result = self._callFUT(model, ('baz',))
+        self.assertEqual(result, baz)
+        self.assertEqual(model.environ['PATH_INFO'], 'baz')
 
-    def test_absolute_found(self):
-        dummy = DummyContext()
+    def test_relative_string_notfound(self):
+        model = DummyContext()
         baz = DummyContext()
-        baz.__parent__ = dummy
-        baz.__name__ = 'baz'
-        dummy.__parent__ = None
-        dummy.__name__ = None
-        traverser = make_traverser(dummy, '', [])
+        traverser = make_traverser(baz, 'bar', [])
         self._registerTraverserFactory(traverser)
-        result = self._callFUT(baz, '/')
-        self.assertEqual(result, dummy)
-        self.assertEqual(dummy.wascontext, True)
+        self.assertRaises(KeyError, self._callFUT, model, 'baz')
+        self.assertEqual(model.environ['PATH_INFO'], 'baz')
 
-    def test_absolute_notfound(self):
-        dummy = DummyContext()
+    def test_relative_tuple_notfound(self):
+        model = DummyContext()
         baz = DummyContext()
-        baz.__parent__ = dummy
-        baz.__name__ = 'baz'
-        dummy.__parent__ = None
-        dummy.__name__ = None
-        traverser = make_traverser(dummy, 'fuz', [])
+        traverser = make_traverser(baz, 'bar', [])
         self._registerTraverserFactory(traverser)
-        self.assertRaises(KeyError, self._callFUT, baz, '/')
-        self.assertEqual(dummy.wascontext, True)
+        self.assertRaises(KeyError, self._callFUT, model, ('baz',))
+        self.assertEqual(model.environ['PATH_INFO'], 'baz')
 
-    def test_unicode_pathinfo_converted_to_utf8(self):
-        la = unicode('LaPe\xc3\xb1a', 'utf-8')
+    def test_absolute_string_found(self):
+        root = DummyContext()
+        model = DummyContext()
+        model.__parent__ = root
+        model.__name__ = 'baz'
+        traverser = make_traverser(root, '', [])
+        self._registerTraverserFactory(traverser)
+        result = self._callFUT(model, '/')
+        self.assertEqual(result, root)
+        self.assertEqual(root.wascontext, True)
+        self.assertEqual(root.environ['PATH_INFO'], '/')
 
-        dummy = DummyContext()
-        dummy.__parent__ = None
-        dummy.__name__ = None
-        baz = DummyContext()
-        baz.__parent__ = dummy
-        baz.__name__ = la
+    def test_absolute_tuple_found(self):
+        root = DummyContext()
+        model = DummyContext()
+        model.__parent__ = root
+        model.__name__ = 'baz'
+        traverser = make_traverser(root, '', [])
+        self._registerTraverserFactory(traverser)
+        result = self._callFUT(model, ('',))
+        self.assertEqual(result, root)
+        self.assertEqual(root.wascontext, True)
+        self.assertEqual(root.environ['PATH_INFO'], '/')
 
-        traverser = make_traverser(baz, '', [])
+    def test_absolute_string_notfound(self):
+        root = DummyContext()
+        model = DummyContext()
+        model.__parent__ = root
+        model.__name__ = 'baz'
+        traverser = make_traverser(root, 'fuz', [])
         self._registerTraverserFactory(traverser)
-        path = '/' + la
-        result = self._callFUT(baz, path)
-        self.assertEqual(result, baz)
-        self.assertEqual(dummy.wascontext, True)
-        self.assertEqual(dummy.environ['PATH_INFO'], path.encode('utf-8'))
+        self.assertRaises(KeyError, self._callFUT, model, '/')
+        self.assertEqual(root.wascontext, True)
+        self.assertEqual(root.environ['PATH_INFO'], '/')
+
+    def test_absolute_tuple_notfound(self):
+        root = DummyContext()
+        model = DummyContext()
+        model.__parent__ = root
+        model.__name__ = 'baz'
+        traverser = make_traverser(root, 'fuz', [])
+        self._registerTraverserFactory(traverser)
+        self.assertRaises(KeyError, self._callFUT, model, ('',))
+        self.assertEqual(root.wascontext, True)
+        self.assertEqual(root.environ['PATH_INFO'], '/')
 
 class ModelPathTests(unittest.TestCase):
     def _callFUT(self, model, *elements):
@@ -356,7 +412,8 @@ class ModelPathTests(unittest.TestCase):
         baz.__parent__ = bar
         baz.__name__ = 'baz'
         result = self._callFUT(baz, 'this/theotherthing', 'that')
-        self.assertEqual(result, '/foo /bar/baz/this/theotherthing/that')
+        self.assertEqual(result, ('','foo ', 'bar', 'baz', 'this/theotherthing',
+                                  'that'))
 
     def test_root_default(self):
         root = DummyContext()
@@ -364,7 +421,7 @@ class ModelPathTests(unittest.TestCase):
         root.__name__ = None
         request = DummyRequest()
         result = self._callFUT(root)
-        self.assertEqual(result, '/')
+        self.assertEqual(result, ('',))
         
     def test_nonroot_default(self):
         root = DummyContext()
@@ -375,7 +432,7 @@ class ModelPathTests(unittest.TestCase):
         other.__name__ = 'other'
         request = DummyRequest()
         result = self._callFUT(other)
-        self.assertEqual(result, '/other')
+        self.assertEqual(result, ('', 'other'))
 
 class TraversalContextURLTests(unittest.TestCase):
     def _makeOne(self, context, url):
@@ -534,6 +591,8 @@ def make_traverser(*args):
     return DummyTraverser
         
 class DummyContext(object):
+    __parent__ = None
+    __name__ = None
     def __init__(self, next=None):
         self.next = next