/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_patches.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_patches.py
17
17
 
18
18
import os.path
19
19
 
20
 
from breezy.tests import TestCase, TestCaseWithTransport
 
20
from breezy.tests import TestCase
21
21
 
22
22
from breezy.iterablefile import IterableFile
23
 
from breezy.patches import (
24
 
    AppliedPatches,
25
 
    MalformedLine,
26
 
    MalformedHunkHeader,
27
 
    MalformedPatchHeader,
28
 
    BinaryPatch,
29
 
    BinaryFiles,
30
 
    Patch,
31
 
    ContextLine,
32
 
    InsertLine,
33
 
    RemoveLine,
34
 
    difference_index,
35
 
    get_patch_names,
36
 
    hunk_from_header,
37
 
    iter_patched,
38
 
    iter_patched_from_hunks,
39
 
    parse_line,
40
 
    parse_patch,
41
 
    parse_patches,
42
 
    NO_NL,
43
 
    )
 
23
from breezy.patches import (MalformedLine,
 
24
                            MalformedHunkHeader,
 
25
                            MalformedPatchHeader,
 
26
                            BinaryPatch,
 
27
                            BinaryFiles,
 
28
                            Patch,
 
29
                            ContextLine,
 
30
                            InsertLine,
 
31
                            RemoveLine,
 
32
                            difference_index,
 
33
                            get_patch_names,
 
34
                            hunk_from_header,
 
35
                            iter_patched,
 
36
                            iter_patched_from_hunks,
 
37
                            parse_line,
 
38
                            parse_patch,
 
39
                            parse_patches,
 
40
                            NO_NL)
44
41
 
45
42
 
46
43
class PatchesTester(TestCase):
48
45
    def datafile(self, filename):
49
46
        data_path = os.path.join(os.path.dirname(__file__),
50
47
                                 "test_patches_data", filename)
51
 
        return open(data_path, "rb")
 
48
        return file(data_path, "rb")
52
49
 
53
50
    def data_lines(self, filename):
54
 
        with self.datafile(filename) as datafile:
 
51
        datafile = self.datafile(filename)
 
52
        try:
55
53
            return datafile.readlines()
 
54
        finally:
 
55
            datafile.close()
56
56
 
57
57
    def test_parse_patches_leading_noise(self):
58
58
        # https://bugs.launchpad.net/bzr/+bug/502076
59
59
        # https://code.launchpad.net/~toshio/bzr/allow-dirty-patches/+merge/18854
60
 
        lines = [b"diff -pruN commands.py",
61
 
                 b"--- orig/commands.py",
62
 
                 b"+++ mod/dommands.py"]
63
 
        bits = list(parse_patches(iter(lines), allow_dirty=True))
 
60
        lines = ["diff -pruN commands.py",
 
61
                 "--- orig/commands.py",
 
62
                 "+++ mod/dommands.py"]
 
63
        bits = parse_patches(iter(lines), allow_dirty=True)
64
64
 
65
65
    def test_preserve_dirty_head(self):
66
66
        """Parse a patch containing a dirty header, and preserve lines"""
67
 
        lines = [b"=== added directory 'foo/bar'\n",
68
 
                 b"=== modified file 'orig/commands.py'\n",
69
 
                 b"--- orig/commands.py\n",
70
 
                 b"+++ mod/dommands.py\n",
71
 
                 b"=== modified file 'orig/another.py'\n",
72
 
                 b"--- orig/another.py\n",
73
 
                 b"+++ mod/another.py\n"]
74
 
        patches = list(parse_patches(
75
 
            lines.__iter__(), allow_dirty=True, keep_dirty=True))
 
67
        lines = ["=== added directory 'foo/bar'\n",
 
68
                 "=== modified file 'orig/commands.py'\n",
 
69
                 "--- orig/commands.py\n",
 
70
                 "+++ mod/dommands.py\n",
 
71
                 "=== modified file 'orig/another.py'\n",
 
72
                 "--- orig/another.py\n",
 
73
                 "+++ mod/another.py\n"]
 
74
        patches = parse_patches(
 
75
            lines.__iter__(), allow_dirty=True, keep_dirty=True)
76
76
        self.assertLength(2, patches)
77
77
        self.assertEqual(patches[0]['dirty_head'],
78
 
                         [b"=== added directory 'foo/bar'\n",
79
 
                          b"=== modified file 'orig/commands.py'\n"])
 
78
                         ["=== added directory 'foo/bar'\n",
 
79
                          "=== modified file 'orig/commands.py'\n"])
80
80
        self.assertEqual(patches[0]['patch'].get_header().splitlines(True),
81
 
                         [b"--- orig/commands.py\n", b"+++ mod/dommands.py\n"])
 
81
                         ["--- orig/commands.py\n", "+++ mod/dommands.py\n"])
82
82
        self.assertEqual(patches[1]['dirty_head'],
83
 
                         [b"=== modified file 'orig/another.py'\n"])
 
83
                         ["=== modified file 'orig/another.py'\n"])
84
84
        self.assertEqual(patches[1]['patch'].get_header().splitlines(True),
85
 
                         [b"--- orig/another.py\n", b"+++ mod/another.py\n"])
 
85
                         ["--- orig/another.py\n", "+++ mod/another.py\n"])
86
86
 
87
87
    def testValidPatchHeader(self):
88
88
        """Parse a valid patch header"""
89
 
        lines = b"--- orig/commands.py\n+++ mod/dommands.py\n".split(b'\n')
 
89
        lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
90
90
        (orig, mod) = get_patch_names(lines.__iter__())
91
 
        self.assertEqual(orig, b"orig/commands.py")
92
 
        self.assertEqual(mod, b"mod/dommands.py")
 
91
        self.assertEqual(orig, "orig/commands.py")
 
92
        self.assertEqual(mod, "mod/dommands.py")
93
93
 
94
94
    def testInvalidPatchHeader(self):
95
95
        """Parse an invalid patch header"""
96
 
        lines = b"-- orig/commands.py\n+++ mod/dommands.py".split(b'\n')
 
96
        lines = "-- orig/commands.py\n+++ mod/dommands.py".split('\n')
97
97
        self.assertRaises(MalformedPatchHeader, get_patch_names,
98
98
                          lines.__iter__())
99
99
 
100
100
    def testValidHunkHeader(self):
101
101
        """Parse a valid hunk header"""
102
 
        header = b"@@ -34,11 +50,6 @@\n"
 
102
        header = "@@ -34,11 +50,6 @@\n"
103
103
        hunk = hunk_from_header(header)
104
104
        self.assertEqual(hunk.orig_pos, 34)
105
105
        self.assertEqual(hunk.orig_range, 11)
106
106
        self.assertEqual(hunk.mod_pos, 50)
107
107
        self.assertEqual(hunk.mod_range, 6)
108
 
        self.assertEqual(hunk.as_bytes(), header)
 
108
        self.assertEqual(str(hunk), header)
109
109
 
110
110
    def testValidHunkHeader2(self):
111
111
        """Parse a tricky, valid hunk header"""
112
 
        header = b"@@ -1 +0,0 @@\n"
 
112
        header = "@@ -1 +0,0 @@\n"
113
113
        hunk = hunk_from_header(header)
114
114
        self.assertEqual(hunk.orig_pos, 1)
115
115
        self.assertEqual(hunk.orig_range, 1)
116
116
        self.assertEqual(hunk.mod_pos, 0)
117
117
        self.assertEqual(hunk.mod_range, 0)
118
 
        self.assertEqual(hunk.as_bytes(), header)
 
118
        self.assertEqual(str(hunk), header)
119
119
 
120
120
    def testPDiff(self):
121
121
        """Parse a hunk header produced by diff -p"""
122
 
        header = b"@@ -407,7 +292,7 @@ bzr 0.18rc1  2007-07-10\n"
 
122
        header = "@@ -407,7 +292,7 @@ bzr 0.18rc1  2007-07-10\n"
123
123
        hunk = hunk_from_header(header)
124
 
        self.assertEqual(b'bzr 0.18rc1  2007-07-10', hunk.tail)
125
 
        self.assertEqual(header, hunk.as_bytes())
 
124
        self.assertEqual('bzr 0.18rc1  2007-07-10', hunk.tail)
 
125
        self.assertEqual(header, str(hunk))
126
126
 
127
127
    def makeMalformed(self, header):
128
128
        self.assertRaises(MalformedHunkHeader, hunk_from_header, header)
129
129
 
130
130
    def testInvalidHeader(self):
131
131
        """Parse an invalid hunk header"""
132
 
        self.makeMalformed(b" -34,11 +50,6 \n")
133
 
        self.makeMalformed(b"@@ +50,6 -34,11 @@\n")
134
 
        self.makeMalformed(b"@@ -34,11 +50,6 @@")
135
 
        self.makeMalformed(b"@@ -34.5,11 +50,6 @@\n")
136
 
        self.makeMalformed(b"@@-34,11 +50,6@@\n")
137
 
        self.makeMalformed(b"@@ 34,11 50,6 @@\n")
138
 
        self.makeMalformed(b"@@ -34,11 @@\n")
139
 
        self.makeMalformed(b"@@ -34,11 +50,6.5 @@\n")
140
 
        self.makeMalformed(b"@@ -34,11 +50,-6 @@\n")
 
132
        self.makeMalformed(" -34,11 +50,6 \n")
 
133
        self.makeMalformed("@@ +50,6 -34,11 @@\n")
 
134
        self.makeMalformed("@@ -34,11 +50,6 @@")
 
135
        self.makeMalformed("@@ -34.5,11 +50,6 @@\n")
 
136
        self.makeMalformed("@@-34,11 +50,6@@\n")
 
137
        self.makeMalformed("@@ 34,11 50,6 @@\n")
 
138
        self.makeMalformed("@@ -34,11 @@\n")
 
139
        self.makeMalformed("@@ -34,11 +50,6.5 @@\n")
 
140
        self.makeMalformed("@@ -34,11 +50,-6 @@\n")
141
141
 
142
142
    def lineThing(self, text, type):
143
143
        line = parse_line(text)
144
144
        self.assertIsInstance(line, type)
145
 
        self.assertEqual(line.as_bytes(), text)
 
145
        self.assertEqual(str(line), text)
146
146
 
147
147
    def makeMalformedLine(self, text):
148
148
        self.assertRaises(MalformedLine, parse_line, text)
149
149
 
150
150
    def testValidLine(self):
151
151
        """Parse a valid hunk line"""
152
 
        self.lineThing(b" hello\n", ContextLine)
153
 
        self.lineThing(b"+hello\n", InsertLine)
154
 
        self.lineThing(b"-hello\n", RemoveLine)
 
152
        self.lineThing(" hello\n", ContextLine)
 
153
        self.lineThing("+hello\n", InsertLine)
 
154
        self.lineThing("-hello\n", RemoveLine)
155
155
 
156
156
    def testMalformedLine(self):
157
157
        """Parse invalid valid hunk lines"""
158
 
        self.makeMalformedLine(b"hello\n")
 
158
        self.makeMalformedLine("hello\n")
159
159
 
160
160
    def testMalformedLineNO_NL(self):
161
 
        """Parse invalid '\\ No newline at end of file' in hunk lines"""
 
161
        """Parse invalid '\ No newline at end of file' in hunk lines"""
162
162
        self.makeMalformedLine(NO_NL)
163
163
 
164
164
    def compare_parsed(self, patchtext):
165
165
        lines = patchtext.splitlines(True)
166
166
        patch = parse_patch(lines.__iter__())
167
 
        pstr = patch.as_bytes()
 
167
        pstr = str(patch)
168
168
        i = difference_index(patchtext, pstr)
169
169
        if i is not None:
170
170
            print("%i: \"%s\" != \"%s\"" % (i, patchtext[i], pstr[i]))
171
 
        self.assertEqual(patchtext, patch.as_bytes())
 
171
        self.assertEqual(patchtext, str(patch))
172
172
 
173
173
    def testAll(self):
174
174
        """Test parsing a whole patch"""
175
 
        with self.datafile("patchtext.patch") as f:
176
 
            patchtext = f.read()
 
175
        patchtext = self.datafile("patchtext.patch").read()
177
176
        self.compare_parsed(patchtext)
178
177
 
179
178
    def test_parse_binary(self):
180
179
        """Test parsing a whole patch"""
181
 
        patches = list(parse_patches(self.data_lines("binary.patch")))
 
180
        patches = parse_patches(self.data_lines("binary.patch"))
182
181
        self.assertIs(BinaryPatch, patches[0].__class__)
183
182
        self.assertIs(Patch, patches[1].__class__)
184
 
        self.assertContainsRe(patches[0].oldname, b'^bar\t')
185
 
        self.assertContainsRe(patches[0].newname, b'^qux\t')
186
 
        self.assertContainsRe(patches[0].as_bytes(),
187
 
                              b'Binary files bar\t.* and qux\t.* differ\n')
 
183
        self.assertContainsRe(patches[0].oldname, '^bar\t')
 
184
        self.assertContainsRe(patches[0].newname, '^qux\t')
 
185
        self.assertContainsRe(str(patches[0]),
 
186
                              'Binary files bar\t.* and qux\t.* differ\n')
188
187
 
189
188
    def test_parse_binary_after_normal(self):
190
 
        patches = list(parse_patches(
191
 
            self.data_lines("binary-after-normal.patch")))
 
189
        patches = parse_patches(self.data_lines("binary-after-normal.patch"))
192
190
        self.assertIs(BinaryPatch, patches[1].__class__)
193
191
        self.assertIs(Patch, patches[0].__class__)
194
 
        self.assertContainsRe(patches[1].oldname, b'^bar\t')
195
 
        self.assertContainsRe(patches[1].newname, b'^qux\t')
196
 
        self.assertContainsRe(patches[1].as_bytes(),
197
 
                              b'Binary files bar\t.* and qux\t.* differ\n')
 
192
        self.assertContainsRe(patches[1].oldname, '^bar\t')
 
193
        self.assertContainsRe(patches[1].newname, '^qux\t')
 
194
        self.assertContainsRe(str(patches[1]),
 
195
                              'Binary files bar\t.* and qux\t.* differ\n')
198
196
 
199
197
    def test_roundtrip_binary(self):
200
 
        patchtext = b''.join(self.data_lines("binary.patch"))
 
198
        patchtext = ''.join(self.data_lines("binary.patch"))
201
199
        patches = parse_patches(patchtext.splitlines(True))
202
 
        self.assertEqual(patchtext, b''.join(p.as_bytes() for p in patches))
 
200
        self.assertEqual(patchtext, ''.join(str(p) for p in patches))
203
201
 
204
202
    def testInit(self):
205
203
        """Handle patches missing half the position, range tuple"""
206
204
        patchtext = \
207
 
            b"""--- orig/__vavg__.cl
 
205
"""--- orig/__vavg__.cl
208
206
+++ mod/__vavg__.cl
209
207
@@ -1 +1,2 @@
210
208
 __qbpsbezng__ = "erfgehpgherqgrkg ra"
287
285
    def testParsePatches(self):
288
286
        """Make sure file names can be extracted from tricky unified diffs"""
289
287
        patchtext = \
290
 
            b"""--- orig-7
 
288
"""--- orig-7
291
289
+++ mod-7
292
290
@@ -1,10 +1,10 @@
293
291
 -- a
312
310
--- C
313
311
+++ D
314
312
"""
315
 
        filenames = [(b'orig-7', b'mod-7'),
316
 
                     (b'orig-8', b'mod-8')]
 
313
        filenames = [('orig-7', 'mod-7'),
 
314
                     ('orig-8', 'mod-8')]
317
315
        patches = parse_patches(patchtext.splitlines(True))
318
316
        patch_files = []
319
317
        for patch in patches:
324
322
        """Test the added, removed and hunks values for stats_values."""
325
323
        patch = parse_patch(self.datafile("diff"))
326
324
        self.assertEqual((299, 407, 48), patch.stats_values())
327
 
 
328
 
 
329
 
class AppliedPatchesTests(TestCaseWithTransport):
330
 
 
331
 
    def test_apply_simple(self):
332
 
        tree = self.make_branch_and_tree('.')
333
 
        self.build_tree_contents([('a', 'a\n')])
334
 
        tree.add('a')
335
 
        tree.commit('Add a')
336
 
        patch = parse_patch(b"""\
337
 
--- a/a
338
 
+++ a/a
339
 
@@ -1 +1 @@
340
 
-a
341
 
+b
342
 
""".splitlines(True))
343
 
        with AppliedPatches(tree, [patch]) as newtree:
344
 
            self.assertEqual(b'b\n', newtree.get_file_text('a'))
345
 
 
346
 
    def test_apply_delete(self):
347
 
        tree = self.make_branch_and_tree('.')
348
 
        self.build_tree_contents([('a', 'a\n')])
349
 
        tree.add('a')
350
 
        tree.commit('Add a')
351
 
        patch = parse_patch(b"""\
352
 
--- a/a
353
 
+++ /dev/null
354
 
@@ -1 +0,0 @@
355
 
-a
356
 
""".splitlines(True))
357
 
        with AppliedPatches(tree, [patch]) as newtree:
358
 
            self.assertFalse(newtree.has_filename('a'))
359
 
 
360
 
    def test_apply_add(self):
361
 
        tree = self.make_branch_and_tree('.')
362
 
        self.build_tree_contents([('a', 'a\n')])
363
 
        tree.add('a')
364
 
        tree.commit('Add a')
365
 
        patch = parse_patch(b"""\
366
 
--- /dev/null
367
 
+++ a/b
368
 
@@ -0,0 +1 @@
369
 
+b
370
 
""".splitlines(True))
371
 
        with AppliedPatches(tree, [patch]) as newtree:
372
 
            self.assertEqual(b'b\n', newtree.get_file_text('b'))