Handle the whole-document pointer in the sequence branch

A whole-document pointer makes JsonPointer.to_last return part None.
The MutableMapping branch replaces the document in that case, and
ReplaceOperation checks for it before branching, but the
MutableSequence branch went straight to `part > len(subobj)` and raised
a bare TypeError, which is not part of the exception hierarchy callers
document.

Add the same `part is None` arm the mapping branch has. move and copy
delegate to AddOperation, so they are fixed by the same change.

Also make the existing object-root test compare rather than pass the
expected value as assertTrue's failure message, which asserted nothing.

Fixes #190

Author: feiiiiii5

jsonpatch.py

@@ -282,7 +282,10 @@ def apply(self, obj):
         subobj, part = self.pointer.to_last(obj)
 
         if isinstance(subobj, MutableSequence):
-            if part == '-':
+            if part is None:
+                return value  # we're replacing the root
+
+            elif part == '-':
                 subobj.append(value)  # pylint: disable=E1103
 
             elif part > len(subobj) or part < 0:

tests.py

@@ -107,7 +107,40 @@ def test_add_replace_whole_document(self):
         obj = {'foo': 'bar'}
         new_obj = {'baz': 'qux'}
         res = jsonpatch.apply_patch(obj, [{'op': 'add', 'path': '', 'value': new_obj}])
-        self.assertTrue(res, new_obj)
+        # assertTrue(res, new_obj) passed a dict as the failure message, so this
+        # asserted nothing; it is the object-root counterpart of the array-root
+        # test below, so it needs to actually compare.
+        self.assertEqual(res, new_obj)
+
+    def test_add_replace_whole_document_list_root(self):
+        # a whole document pointer resolves to part None, which has to replace
+        # the document no matter whether the root is an object or an array
+        obj = ['foo', 'bar']
+        new_obj = {'baz': 'qux'}
+        res = jsonpatch.apply_patch(obj, [{'op': 'add', 'path': '', 'value': new_obj}])
+        self.assertEqual(res, new_obj)
+
+    def test_move_whole_document_list_root(self):
+        # move and copy reuse AddOperation, so they need the same treatment
+        obj = ['foo', 'bar']
+        res = jsonpatch.apply_patch(obj, [{'op': 'move', 'from': '/0', 'path': ''}])
+        self.assertEqual(res, 'foo')
+
+    def test_copy_whole_document_list_root(self):
+        obj = ['foo', 'bar']
+        res = jsonpatch.apply_patch(obj, [{'op': 'copy', 'from': '/1', 'path': ''}])
+        self.assertEqual(res, 'bar')
+
+    def test_add_whole_document_list_root_raises_no_bare_typeerror(self):
+        # a bare TypeError is not part of the documented exception hierarchy, so
+        # callers cannot catch it; the sequence branch must not fall through to it
+        obj = ['foo', 'bar']
+        try:
+            jsonpatch.apply_patch(obj, [{'op': 'add', 'path': '', 'value': 'R'}])
+        except jsonpatch.JsonPatchException:
+            self.fail("root add on an array root should succeed, not raise")
+        except TypeError:
+            self.fail("root add on an array root raised a bare TypeError")
 
     def test_replace_array_item(self):
         obj = {'foo': ['bar', 'qux', 'baz']}