Merge branch 'thekafkaf-broad-exception-handling'

2 files changed, 84 insertions, 44 deletions

diff --git a/jsonpointer.py b/jsonpointer.py
index 4f2bfc7..9a6a613 100644
--- a/jsonpointer.py
+++ b/jsonpointer.py
@@ -228,26 +228,18 @@ class JsonPointer(object):
             return part
 
         else:
-            raise JsonPointerException("document '%s' does not support indexing, "
+            raise JsonPointerException("Document '%s' does not support indexing, "
                                        "must be mapping/sequence or support __getitem__" % type(doc))
 
+
     def walk(self, doc, part):
-        """Walks one step in doc and returns the referenced part"""
+        """ Walks one step in doc and returns the referenced part """
 
         part = self.get_part(doc, part)
 
-        assert hasattr(doc, '__getitem__'), \
-            'invalid document type %s' % type(doc)
-
-        if isinstance(doc, Mapping):
-            try:
-                return doc[part]
-
-            except KeyError:
-                raise JsonPointerException("member '%s' not found in %s" % (part, doc))
-
-        elif isinstance(doc, Sequence):
+        assert hasattr(doc, '__getitem__'), "invalid document type %s" % (type(doc),)
 
+        if isinstance(doc, Sequence):
             if part == '-':
                 return EndOfList(doc)
 
@@ -257,16 +249,20 @@ class JsonPointer(object):
             except IndexError:
                 raise JsonPointerException("index '%s' is out of bounds" % (part, ))
 
-        else:
-            # Object supports __getitem__, assume custom indexing
+        # Else the object is a mapping or supports __getitem__(so assume custom indexing)
+        try:
             return doc[part]
 
+        except KeyError:
+            raise JsonPointerException("member '%s' not found in %s" % (part, doc))
+
+
     def contains(self, ptr):
-        """Returns True if self contains the given ptr"""
+        """ Returns True if self contains the given ptr """
         return self.parts[:len(ptr.parts)] == ptr.parts
 
     def __contains__(self, item):
-        """Returns True if self contains the given ptr"""
+        """ Returns True if self contains the given ptr """
         return self.contains(item)
 
     @property
diff --git a/tests.py b/tests.py
index cf5c61a..21483eb 100755
--- a/tests.py
+++ b/tests.py
@@ -10,6 +10,7 @@ import copy
 from jsonpointer import resolve_pointer, EndOfList, JsonPointerException, \
          JsonPointer, set_pointer
 
+
 class SpecificationTests(unittest.TestCase):
     """ Tests all examples from the JSON Pointer specification """
 
@@ -73,6 +74,7 @@ class SpecificationTests(unittest.TestCase):
             new_ptr = JsonPointer.from_parts(parts)
             self.assertEqual(ptr, new_ptr)
 
+
 class ComparisonTests(unittest.TestCase):
 
     def setUp(self):
@@ -108,7 +110,6 @@ class ComparisonTests(unittest.TestCase):
         self.assertTrue(self.ptr1 in self.ptr1)
         self.assertFalse(self.ptr3 in self.ptr1)
 
-
 class WrongInputTests(unittest.TestCase):
 
     def test_no_start_slash(self):
@@ -192,42 +193,52 @@ class SetTests(unittest.TestCase):
 
         self.assertRaises(JsonPointerException, set_pointer, doc, "", 9)
 
+
 class AltTypesTests(unittest.TestCase):
 
-    def test_alttypes(self):
-        JsonPointer.alttypes = True
+    class Node(object):
+        def __init__(self, name, parent=None):
+            self.name = name
+            self.parent = parent
+            self.left = None
+            self.right = None
 
-        class Node(object):
-            def __init__(self, name, parent=None):
-                self.name = name
-                self.parent = parent
-                self.left = None
-                self.right = None
+        def set_left(self, node):
+            node.parent = self
+            self.left = node
 
-            def set_left(self, node):
-                node.parent = self
-                self.left = node
+        def set_right(self, node):
+            node.parent = self
+            self.right = node
 
-            def set_right(self, node):
-                node.parent = self
-                self.right = node
+        def __getitem__(self, key):
+            if key == 'left':
+                return self.left
+            if key == 'right':
+                return self.right
 
-            def __getitem__(self, key):
-                if key == 'left':
-                    return self.left
-                if key == 'right':
-                    return self.right
+            raise KeyError("Only left and right supported")
 
-                raise KeyError("Only left and right supported")
+        def __setitem__(self, key, val):
+            if key == 'left':
+                return self.set_left(val)
+            if key == 'right':
+                return self.set_right(val)
 
-            def __setitem__(self, key, val):
-                if key == 'left':
-                    return self.set_left(val)
-                if key == 'right':
-                    return self.set_right(val)
+            raise KeyError("Only left and right supported: %s" % key)
 
-                raise KeyError("Only left and right supported: %s" % key)
+    class mdict(object):
+        def __init__(self, d):
+            self._d = d
+        def __getitem__(self, item):
+            return self._d[item]
 
+    mdict = mdict({'root': {'1': {'2': '3'}}})
+    Node = Node
+
+
+    def test_alttypes(self):
+        Node = self.Node
 
         root = Node('root')
         root.set_left(Node('a'))
@@ -249,6 +260,39 @@ class AltTypesTests(unittest.TestCase):
         set_pointer(root, '/left/right', Node('AB'))
         self.assertEqual(resolve_pointer(root, '/left/right').name, 'AB')
 
+    def test_mock_dict_sanity(self):
+        doc = self.mdict
+        default = None
+
+        # TODO: Generate this automatically for any given object
+        path_to_expected_value = {
+            '/root/1': {'2': '3'},
+            '/root': {'1': {'2': '3'}},
+            '/root/1/2': '3',
+        }
+
+        for path, expected_value in iter(path_to_expected_value.items()):
+            self.assertEqual(resolve_pointer(doc, path, default), expected_value)
+
+    def test_mock_dict_returns_default(self):
+        doc = self.mdict
+        default = None
+
+        path_to_expected_value = {
+            '/foo': default,
+            '/x/y/z/d': default
+        }
+
+        for path, expected_value in iter(path_to_expected_value.items()):
+            self.assertEqual(resolve_pointer(doc, path, default), expected_value)
+
+    def test_mock_dict_raises_key_error(self):
+        doc = self.mdict
+        self.assertRaises(JsonPointerException, resolve_pointer, doc, '/foo')
+        self.assertRaises(JsonPointerException, resolve_pointer, doc, '/root/1/2/3/4')
+
+
+
 suite = unittest.TestSuite()
 suite.addTest(unittest.makeSuite(SpecificationTests))
 suite.addTest(unittest.makeSuite(ComparisonTests))