jsonpatch 1.35__tar.gz → 1.37__tar.gz

{jsonpatch-1.35/jsonpatch.egg-info → jsonpatch-1.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonpatch
-Version: 1.35
+Version: 1.37
 Summary:  Apply JSON-Patches (RFC 6902) 
 Home-page: https://github.com/stefankoegl/python-json-patch
 Author: Stefan Kögl

{jsonpatch-1.35 → jsonpatch-1.37/jsonpatch.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonpatch
-Version: 1.35
+Version: 1.37
 Summary:  Apply JSON-Patches (RFC 6902) 
 Home-page: https://github.com/stefankoegl/python-json-patch
 Author: Stefan Kögl

{jsonpatch-1.35 → jsonpatch-1.37}/jsonpatch.py

@@ -54,7 +54,7 @@ _EXACT_MATCH_LIMIT = 500 ** 2
 
 # Will be parsed by setup.py to determine package metadata
 __author__ = 'Stefan Kögl <stefan@skoegl.net>'
-__version__ = '1.35'
+__version__ = '1.37'
 __website__ = 'https://github.com/stefankoegl/python-json-patch'
 __license__ = 'BSD-3-Clause'
 
@@ -384,7 +384,7 @@ class MoveOperation(PatchOperation):
 
     @property
     def from_path(self):
-        from_ptr = self.pointer_cls(self.operation['from'])
+        from_ptr = self._from_pointer()
         return '/'.join(from_ptr.parts[:-1])
 
     @property
@@ -396,14 +396,14 @@ class MoveOperation(PatchOperation):
         self.set_from_part(-1, value)
 
     def get_from_part(self, index):
-        from_ptr = self.pointer_cls(self.operation['from'])
+        from_ptr = self._from_pointer()
         try:
             return int(from_ptr.parts[index])
         except ValueError:
             return from_ptr.parts[index]
 
     def set_from_part(self, index, value):
-        from_ptr = self.pointer_cls(self.operation['from'])
+        from_ptr = self._from_pointer()
         from_ptr.parts[index] = str(value)
         self.operation['from'] = from_ptr.path
 
@@ -518,11 +518,18 @@ class JsonPatch(object):
         self.patch = patch
         self.pointer_cls = pointer_cls
 
+        if isinstance(patch, (str, bytes, Mapping)):
+            raise InvalidJsonPatch("Document is expected to be sequence of operations")
+        try:
+            patch_iter = iter(patch)
+        except TypeError:
+            raise InvalidJsonPatch("Document is expected to be sequence of operations")
+
         # Verify that the structure of the patch document
         # is correct by retrieving each patch element.
         # Much of the validation is done in the initializer
         # though some is delayed until the patch is applied.
-        for op in self.patch:
+        for op in patch_iter:
             # We're only checking for strings in the following check
             # for two reasons:
             #
@@ -597,6 +604,10 @@ class JsonPatch(object):
         :param dst: Data target document object.
         :type dst: dict
 
+        :param optimization: Generate move operations for matching values.
+                             Set to False to use only add, remove and replace.
+        :type optimization: bool
+
         :param dumps: A function of one argument that produces a serialized
                       JSON string.
         :type dumps: Callable
@@ -614,7 +625,8 @@ class JsonPatch(object):
         True
         """
         json_dumper = dumps or cls.json_dumper
-        builder = DiffBuilder(src, dst, json_dumper, pointer_cls=pointer_cls)
+        builder = DiffBuilder(src, dst, json_dumper, pointer_cls=pointer_cls,
+                              optimization=optimization)
         builder._compare_values((), None, src, dst)
         ops = list(builder.execute())
         return cls(ops, pointer_cls=pointer_cls)
@@ -670,9 +682,11 @@ class JsonPatch(object):
 
 class DiffBuilder(object):
 
-    def __init__(self, src_doc, dst_doc, dumps=json.dumps, pointer_cls=JsonPointer):
+    def __init__(self, src_doc, dst_doc, dumps=json.dumps, pointer_cls=JsonPointer,
+                 optimization=True):
         self.dumps = dumps
         self.pointer_cls = pointer_cls
+        self.optimization = optimization
         self.index_storage = [{}, {}]
         self.__root = root = []
         self.src_doc = src_doc
@@ -693,10 +707,14 @@ class DiffBuilder(object):
             return id(value)
 
     def store_index(self, value, index, st):
+        if not self.optimization:
+            return
         storage = self.index_storage[st]
         storage.setdefault(self._move_key(value), []).append(index)
 
     def take_index(self, value, st):
+        if not self.optimization:
+            return None
         stored = self.index_storage[st].get(self._move_key(value))
         if stored:
             return stored.pop()

{jsonpatch-1.35 → jsonpatch-1.37}/jsonpatch_cli.py

@@ -12,8 +12,8 @@ import argparse
 
 jsondiff_parser = argparse.ArgumentParser(
     prog='jsondiff', description='Diff two JSON files')
-jsondiff_parser.add_argument('FILE1', type=argparse.FileType('r'))
-jsondiff_parser.add_argument('FILE2', type=argparse.FileType('r'))
+jsondiff_parser.add_argument('FILE1', type=argparse.FileType('r', encoding='utf-8'))
+jsondiff_parser.add_argument('FILE2', type=argparse.FileType('r', encoding='utf-8'))
 jsondiff_parser.add_argument('--indent', type=int, default=None,
                              help='Indent output by n spaces')
 jsondiff_parser.add_argument('-u', '--preserve-unicode', action='store_true',
@@ -43,9 +43,9 @@ def diff_files():
 jsonpatch_parser = argparse.ArgumentParser(
     prog='jsonpatch',
     description='Apply a JSON patch on a JSON file')
-jsonpatch_parser.add_argument('ORIGINAL', type=argparse.FileType('r'),
+jsonpatch_parser.add_argument('ORIGINAL', type=argparse.FileType('r', encoding='utf-8'),
                               help='Original file')
-jsonpatch_parser.add_argument('PATCH', type=argparse.FileType('r'),
+jsonpatch_parser.add_argument('PATCH', type=argparse.FileType('r', encoding='utf-8'),
                               nargs='?', default=sys.stdin,
                               help='Patch file (read from stdin if omitted)')
 jsonpatch_parser.add_argument('--indent', type=int, default=None,
@@ -86,7 +86,7 @@ def patch_files():
 	    # because atomic renames do not work across mount points.)
 
             fd, pathname = tempfile.mkstemp(dir=dirname)
-            fp = os.fdopen(fd, 'w')
+            fp = os.fdopen(fd, 'w', encoding='utf-8')
             atomic = True
 
         except OSError:
@@ -96,7 +96,7 @@ def patch_files():
 
             if args.backup:
                 os.rename(args.ORIGINAL.name, args.ORIGINAL.name + '.orig')
-            fp = open(args.ORIGINAL.name, 'w')
+            fp = open(args.ORIGINAL.name, 'w', encoding='utf-8')
             atomic = False
 
     else:
@@ -108,15 +108,26 @@ def patch_files():
     # By this point we have some sort of file object we can write the 
     # modified JSON to.
     
-    json.dump(result, fp, indent=args.indent, ensure_ascii=not(args.preserve_unicode))
-    fp.write('\n')
+    try:
+        json.dump(result, fp, indent=args.indent, ensure_ascii=not(args.preserve_unicode))
+        fp.write('\n')
+        if args.in_place:
+            fp.close()
+    except BaseException:
+        if args.in_place:
+            # Cleanup must not replace the original output error.
+            try:
+                fp.close()
+            except OSError:
+                pass
+            if atomic:
+                try:
+                    os.unlink(pathname)
+                except OSError:
+                    pass
+        raise
 
     if args.in_place:
-        # Close the new file.  If we aren't replacing atomically, this
-        # is our last step, since everything else is already in place.
-
-        fp.close()
-
         if atomic:
             try:
                 # Complete the atomic replace by linking the original
@@ -126,12 +137,11 @@ def patch_files():
                 if args.backup:
                     os.link(args.ORIGINAL.name, args.ORIGINAL.name + '.orig')
                 os.chmod(pathname, os.stat(args.ORIGINAL.name).st_mode)
-                os.rename(pathname, args.ORIGINAL.name)
+                os.replace(pathname, args.ORIGINAL.name)
 
             except OSError:
-                # In the event we could not actually do the atomic
-                # replace, unlink the original to move it out of the
-                # way and finally move the temporary file into place.
-                
-                os.unlink(args.ORIGINAL.name)
-                os.rename(pathname, args.ORIGINAL.name)
+                # Preserve the original if backup, permissions, or replacement
+                # fails. replace() can overwrite an existing file on Windows
+                # without unlinking it first.
+                os.unlink(pathname)
+                raise

{jsonpatch-1.35 → jsonpatch-1.37}/property_tests.py

@@ -290,6 +290,15 @@ class MakePatchProperties(unittest.TestCase):
     def test_roundtrip(self, docs):
         self.check_roundtrip(*docs)
 
+    @given(doc_pairs)
+    def test_roundtrip_without_move_optimization(self, docs):
+        src, dst = docs
+        patch = jsonpatch.JsonPatch.from_diff(src, dst, optimization=False)
+        note(patch.patch)
+        self.assertTrue(all(op['op'] in ('add', 'remove', 'replace')
+                            for op in patch))
+        assert_json_equal(patch.apply(src), dst)
+
     @given(safe_doc_pairs)
     # the diff considered e.g. 1 and true equal, #180
     @example(docs=([0], [False]))
@@ -315,6 +324,15 @@ class MakePatchProperties(unittest.TestCase):
 
 class ApplyPatchProperties(unittest.TestCase):
 
+    @given(st.one_of(json_scalars, st.dictionaries(json_keys, json_docs)))
+    @example(patch={})
+    @example(patch='')
+    def test_non_array_patch_documents_are_rejected(self, patch):
+        with self.assertRaises(jsonpatch.InvalidJsonPatch):
+            jsonpatch.JsonPatch(patch)
+        with self.assertRaises(jsonpatch.InvalidJsonPatch):
+            jsonpatch.JsonPatch.from_string(json.dumps(patch))
+
     @given(docs_with_patches())
     def test_does_not_modify_document(self, case):
         doc, patch = case

{jsonpatch-1.35 → jsonpatch-1.37}/tests.py

@@ -21,6 +21,25 @@ from unittest import mock
 
 class ApplyPatchTestCase(unittest.TestCase):
 
+    def test_diff_without_optimization_uses_basic_operations(self):
+        documents = [
+            ({'old': {'value': 1}}, {'new': {'value': 1}}),
+            ([1, 2, 3], [3, 1, 2]),
+            ([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}]),
+            ({'a/b': [1, 2]}, {'~key': [1, 2]}),
+        ]
+        for src, dst in documents:
+            with self.subTest(src=src, dst=dst):
+                original = copy.deepcopy(src)
+                patch = jsonpatch.JsonPatch.from_diff(
+                    src, dst, optimization=False)
+                self.assertTrue(all(operation['op'] in
+                                    ('add', 'remove', 'replace')
+                                    for operation in patch))
+                self.assertEqual(patch.apply(src), dst)
+                self.assertEqual(src, original)
+
+
     def test_js_file(self):
         with open('./tests.js', 'r') as f:
             tests = json.load(f)
@@ -1514,6 +1533,35 @@ class JsonPointerTests(unittest.TestCase):
 
 class JsonPatchCreationTest(unittest.TestCase):
 
+    def test_creation_rejects_non_sequence_documents(self):
+        for patch in ({}, {'op': 'add', 'path': '/a', 'value': 1},
+                      MappingProxyType({}), '', b'', None, True, False,
+                      0, 1, 1.5):
+            with self.subTest(patch=patch):
+                with self.assertRaises(jsonpatch.InvalidJsonPatch):
+                    jsonpatch.JsonPatch(patch)
+
+    def test_serialized_patch_rejects_non_array_documents(self):
+        for patch in ({}, {'op': 'add', 'path': '/a', 'value': 1},
+                      '', 'text', None, True, False, 0, 1, 1.5):
+            for serialized in (json.dumps(patch), json.dumps(patch).encode()):
+                with self.subTest(patch=serialized):
+                    with self.assertRaises(jsonpatch.InvalidJsonPatch):
+                        jsonpatch.JsonPatch.from_string(serialized)
+                    doc = {'a': 'unchanged'}
+                    with self.assertRaises(jsonpatch.InvalidJsonPatch):
+                        jsonpatch.apply_patch(doc, serialized, in_place=True)
+                    self.assertEqual(doc, {'a': 'unchanged'})
+
+    def test_creation_preserves_operation_sequences(self):
+        for operations in ([], (),
+                           [{'op': 'add', 'path': '/a', 'value': 1}],
+                           ({'op': 'add', 'path': '/a', 'value': 1},)):
+            with self.subTest(operations=operations):
+                patch = jsonpatch.JsonPatch(operations)
+                self.assertIs(patch.patch, operations)
+                self.assertEqual(patch.apply({}), {'a': 1} if operations else {})
+
     def test_creation_fails_with_invalid_patch(self):
         invalid_patches = [
             {             'path': '/foo', 'value': 'bar'},
@@ -1657,6 +1705,34 @@ class OperationLocationTests(unittest.TestCase):
         self.assertEqual(operation, {'op': 'move', 'from': '/c~1d/0', 'path': '/b'})
         self.assertEqual(op.apply({'c/d': ['x']}), {'c/d': [], 'b': 'x'})
 
+    def test_from_path_with_pointer_object(self):
+        for pointer_cls in (jsonpointer.JsonPointer, CustomJsonPointer):
+            with self.subTest(pointer_cls=pointer_cls):
+                op = jsonpatch.MoveOperation(
+                    {'op': 'move', 'from': pointer_cls('/a/1/b'), 'path': '/c'},
+                    pointer_cls=pointer_cls)
+                self.assertEqual(op.from_path, 'a/1')
+
+    def test_from_parts_with_pointer_object(self):
+        for pointer_cls in (jsonpointer.JsonPointer, CustomJsonPointer):
+            with self.subTest(pointer_cls=pointer_cls):
+                op = jsonpatch.MoveOperation(
+                    {'op': 'move', 'from': pointer_cls('/a/1/b'), 'path': '/c'},
+                    pointer_cls=pointer_cls)
+                self.assertEqual(op.from_key, 'b')
+                self.assertEqual(op.get_from_part(1), 1)
+
+    def test_set_from_key_with_pointer_object(self):
+        for pointer_cls in (jsonpointer.JsonPointer, CustomJsonPointer):
+            with self.subTest(pointer_cls=pointer_cls):
+                operation = {'op': 'move', 'from': pointer_cls('/a/1'),
+                             'path': '/b'}
+                op = jsonpatch.MoveOperation(operation, pointer_cls=pointer_cls)
+                op.from_key = 0
+                self.assertEqual(operation['from'], '/a/0')
+                self.assertEqual(op.apply({'a': ['x', 'y']}),
+                                 {'a': ['y'], 'b': 'x'})
+
 
 class CustomJsonPointer(jsonpointer.JsonPointer):
     pass
@@ -1817,28 +1893,35 @@ class CommandLineTests(unittest.TestCase):
         self.addCleanup(tmp.cleanup)
         self.dir = tmp.name
 
-    def write(self, name, value):
+    def write(self, name, value, ensure_ascii=True):
         path = os.path.join(self.dir, name)
         with open(path, 'w', encoding='utf-8') as f:
-            json.dump(value, f)
+            json.dump(value, f, ensure_ascii=ensure_ascii)
         return path
 
     def read(self, path):
         with open(path, encoding='utf-8') as f:
             return json.load(f)
 
-    def run_script(self, script, *args, stdin=''):
+    def run_python(self, code, *args, stdin='', utf8=True):
         here = os.path.dirname(os.path.abspath(__file__))
         # the scripts have to import this jsonpatch, not an installed one
         pythonpath = [here] + [p for p in [os.environ.get('PYTHONPATH')] if p]
         env = dict(os.environ, PYTHONPATH=os.pathsep.join(pythonpath),
                    PYTHONUTF8='1')
+        if not utf8:
+            # Exercise locale-dependent file I/O while keeping pipes in UTF-8.
+            env.update(PYTHONUTF8='0', PYTHONIOENCODING='utf-8',
+                       LC_ALL='C', PYTHONCOERCECLOCALE='0')
         return subprocess.run(
-            [sys.executable, '-c',
-             'import jsonpatch_cli; jsonpatch_cli.{0}_main()'.format(script)]
-            + list(args),
+            [sys.executable, '-c', code] + list(args),
             input=stdin, capture_output=True, encoding='utf-8', env=env)
 
+    def run_script(self, script, *args, stdin='', utf8=True):
+        return self.run_python(
+            'import jsonpatch_cli; jsonpatch_cli.{0}_main()'.format(script),
+            *args, stdin=stdin, utf8=utf8)
+
     def test_jsondiff(self):
         src = self.write('a.json', {'a': [1, 2], 'b': 0})
         dst = self.write('b.json', {'a': [1, 2, 3], 'c': 100})
@@ -1868,6 +1951,18 @@ class CommandLineTests(unittest.TestCase):
         self.assertIn('"\\u00e4"', self.run_script('jsondiff', src, dst).stdout)
         self.assertIn('"ä"', self.run_script('jsondiff', '-u', src, dst).stdout)
 
+    def test_jsondiff_utf8_files_without_utf8_mode(self):
+        src = self.write('a.json', {'a': 'old', 'unchanged': 'ä'},
+                         ensure_ascii=False)
+        dst = self.write('b.json', {'a': '🚀', 'unchanged': 'ä'},
+                         ensure_ascii=False)
+        res = self.run_script('jsondiff', src, dst, utf8=False)
+        self.assertEqual(res.returncode, 1, res.stderr)
+        patch = json.loads(res.stdout)
+        self.assertEqual(patch, [{'op': 'replace', 'path': '/a', 'value': '🚀'}])
+        self.assertEqual(jsonpatch.apply_patch(self.read(src), patch),
+                         self.read(dst))
+
     def test_jsonpatch(self):
         doc = self.write('doc.json', {'a': [1, 2], 'b': 0})
         patch = self.write('patch.json', [{'op': 'add', 'path': '/a/-', 'value': 3},
@@ -1884,6 +1979,17 @@ class CommandLineTests(unittest.TestCase):
         self.assertEqual(res.returncode, 0, res.stderr)
         self.assertEqual(json.loads(res.stdout), {'a': 2})
 
+    def test_jsonpatch_utf8_files_without_utf8_mode(self):
+        doc = self.write('doc.json', {'a': 'ä'}, ensure_ascii=False)
+        patch = self.write('patch.json', [
+            {'op': 'test', 'path': '/a', 'value': 'ä'},
+            {'op': 'replace', 'path': '/a', 'value': '🚀'},
+        ], ensure_ascii=False)
+        res = self.run_script('jsonpatch', doc, patch, utf8=False)
+        self.assertEqual(res.returncode, 0, res.stderr)
+        self.assertEqual(json.loads(res.stdout), {'a': '🚀'})
+        self.assertEqual(self.read(doc), {'a': 'ä'})
+
     def test_jsonpatch_indent_preserve_unicode(self):
         doc = self.write('doc.json', {'a': 'x'})
         patch = self.write('patch.json', [{'op': 'replace', 'path': '/a', 'value': 'ä'}])
@@ -1901,22 +2007,44 @@ class CommandLineTests(unittest.TestCase):
         # the temporary file has been moved over the original
         self.assertEqual(sorted(os.listdir(self.dir)), ['doc.json', 'patch.json'])
 
+    def test_jsonpatch_in_place_utf8_without_utf8_mode(self):
+        for atomic in (True, False):
+            with self.subTest(atomic=atomic):
+                doc = self.write('doc.json', {'a': 'old'})
+                patch = self.write('patch.json', [
+                    {'op': 'replace', 'path': '/a', 'value': '🚀'},
+                ])
+                if atomic:
+                    code = 'import jsonpatch_cli; jsonpatch_cli.jsonpatch_main()'
+                else:
+                    code = (
+                        'from unittest import mock\n'
+                        'import jsonpatch_cli\n'
+                        'with mock.patch("tempfile.mkstemp", side_effect=OSError):\n'
+                        '    jsonpatch_cli.jsonpatch_main()\n'
+                    )
+                res = self.run_python(code, '-i', '-u', doc, patch, utf8=False)
+                self.assertEqual((res.returncode, res.stdout), (0, ''), res.stderr)
+                self.assertEqual(self.read(doc), {'a': '🚀'})
+                self.assertEqual(sorted(os.listdir(self.dir)),
+                                 ['doc.json', 'patch.json'])
+
     # 2026-10-11: Windows cannot replace the original while its input is open.
-    def test_jsonpatch_in_place_closes_original_before_rename(self):
+    def test_jsonpatch_in_place_closes_original_before_replace(self):
         doc = self.write('doc.json', {'a': 1})
         patch = self.write('patch.json', [{'op': 'replace', 'path': '/a', 'value': 2}])
         parser = jsonpatch_cli.jsonpatch_parser
         args = parser.parse_args(['-i', doc, patch])
         self.addCleanup(args.ORIGINAL.close)
         self.addCleanup(args.PATCH.close)
-        rename = os.rename
+        replace = os.replace
 
-        def rename_closed_original(source, target):
+        def replace_closed_original(source, target):
             self.assertTrue(args.ORIGINAL.closed)
-            return rename(source, target)
+            return replace(source, target)
 
         with mock.patch.object(parser, 'parse_args', return_value=args), \
-                mock.patch('os.rename', side_effect=rename_closed_original):
+                mock.patch('os.replace', side_effect=replace_closed_original):
             jsonpatch_cli.patch_files()
         self.assertEqual(self.read(doc), {'a': 2})
 
@@ -1937,6 +2065,101 @@ class CommandLineTests(unittest.TestCase):
         self.assertEqual(self.read(doc), {'a': 2})
         self.assertEqual(self.read(doc + '.orig'), {'a': 1})
 
+    def test_jsonpatch_in_place_cleans_temp_on_output_error(self):
+        for phase in ('dump', 'newline', 'close', 'dump_and_close'):
+            with self.subTest(phase=phase):
+                tmp = tempfile.TemporaryDirectory()
+                self.addCleanup(tmp.cleanup)
+                self.dir = tmp.name
+                doc = self.write('doc.json', {'a': 1})
+                patch = self.write('patch.json', [])
+                args = jsonpatch_cli.jsonpatch_parser.parse_args(['-i', doc, patch])
+                self.addCleanup(args.ORIGINAL.close)
+                self.addCleanup(args.PATCH.close)
+                failure = OSError('output failed')
+                opened = []
+                fdopen = os.fdopen
+
+                def open_output(fd, mode, **kwargs):
+                    stream = fdopen(fd, mode, **kwargs)
+                    self.addCleanup(stream.close)
+                    opened.append(stream)
+                    proxy = mock.Mock(wraps=stream)
+                    if phase == 'newline':
+                        proxy.write.side_effect = lambda value: (
+                            stream.write(value) if value != '\n' else fail())
+                    if phase in ('close', 'dump_and_close'):
+                        def close():
+                            stream.close()
+                            raise failure if phase == 'close' else OSError('close failed')
+                        proxy.close.side_effect = close
+                    return proxy
+
+                def fail():
+                    raise failure
+
+                def dump(value, stream, **kwargs):
+                    stream.write('{')
+                    if phase in ('dump', 'dump_and_close'):
+                        raise failure
+
+                with mock.patch.object(jsonpatch_cli.jsonpatch_parser, 'parse_args',
+                                       return_value=args), \
+                        mock.patch('os.fdopen', side_effect=open_output), \
+                        mock.patch('json.dump', side_effect=dump):
+                    with self.assertRaises(OSError) as caught:
+                        jsonpatch_cli.patch_files()
+                self.assertIs(caught.exception, failure)
+                self.assertTrue(opened[0].closed)
+                self.assertEqual(self.read(doc), {'a': 1})
+                self.assertEqual(sorted(os.listdir(self.dir)), ['doc.json', 'patch.json'])
+
+    def test_jsonpatch_in_place_preserves_original_on_replace_error(self):
+        doc = self.write('doc.json', {'a': 1})
+        patch = self.write('patch.json', [{'op': 'replace', 'path': '/a', 'value': 2}])
+        parser = jsonpatch_cli.jsonpatch_parser
+        args = parser.parse_args(['-i', doc, patch])
+        self.addCleanup(args.ORIGINAL.close)
+        self.addCleanup(args.PATCH.close)
+
+        with mock.patch.object(parser, 'parse_args', return_value=args), \
+                mock.patch('os.rename', side_effect=PermissionError('cannot replace')), \
+                mock.patch('os.replace', side_effect=PermissionError('cannot replace')):
+            with self.assertRaises(PermissionError):
+                jsonpatch_cli.patch_files()
+
+        self.assertTrue(os.path.exists(doc))
+        self.assertEqual(self.read(doc), {'a': 1})
+        self.assertEqual(sorted(os.listdir(self.dir)), ['doc.json', 'patch.json'])
+
+    def test_jsonpatch_in_place_preserves_original_on_chmod_error(self):
+        doc = self.write('doc.json', {'a': 1})
+        patch = self.write('patch.json', [{'op': 'replace', 'path': '/a', 'value': 2}])
+        parser = jsonpatch_cli.jsonpatch_parser
+        args = parser.parse_args(['-i', doc, patch])
+        self.addCleanup(args.ORIGINAL.close)
+        self.addCleanup(args.PATCH.close)
+
+        with mock.patch.object(parser, 'parse_args', return_value=args), \
+                mock.patch('os.chmod', side_effect=PermissionError('cannot chmod')):
+            with self.assertRaises(PermissionError):
+                jsonpatch_cli.patch_files()
+
+        self.assertEqual(self.read(doc), {'a': 1})
+        self.assertEqual(sorted(os.listdir(self.dir)), ['doc.json', 'patch.json'])
+
+    def test_jsonpatch_in_place_existing_backup(self):
+        doc = self.write('doc.json', {'a': 1})
+        patch = self.write('patch.json', [{'op': 'replace', 'path': '/a', 'value': 2}])
+        backup = self.write('doc.json.orig', {'previous': True})
+        res = self.run_script('jsonpatch', '-i', '-b', doc, patch)
+
+        self.assertNotEqual(res.returncode, 0)
+        self.assertEqual(self.read(doc), {'a': 1})
+        self.assertEqual(self.read(backup), {'previous': True})
+        self.assertEqual(sorted(os.listdir(self.dir)),
+                         ['doc.json', 'doc.json.orig', 'patch.json'])
+
     def test_jsonpatch_in_place_failing_patch(self):
         # the patch is applied before the file is replaced, so it is kept
         doc = self.write('doc.json', {'a': 1})