/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: 2018-11-16 13:07:04 UTC
  • mto: This revision was merged to the branch mainline in revision 7174.
  • Revision ID: jelmer@jelmer.uk-20181116130704-prj4jo8otlee68qf
Use flake8 rather than pyflakes.

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 bzrlib.tests import TestCase
 
20
from breezy.tests import TestCase
21
21
 
22
 
from bzrlib.iterablefile import IterableFile
23
 
from bzrlib.patches import (MalformedLine,
 
22
from breezy.iterablefile import IterableFile
 
23
from breezy.patches import (MalformedLine,
24
24
                            MalformedHunkHeader,
25
25
                            MalformedPatchHeader,
26
26
                            BinaryPatch,
45
45
    def datafile(self, filename):
46
46
        data_path = os.path.join(os.path.dirname(__file__),
47
47
                                 "test_patches_data", filename)
48
 
        return file(data_path, "rb")
 
48
        return open(data_path, "rb")
49
49
 
50
50
    def data_lines(self, filename):
51
 
        datafile = self.datafile(filename)
52
 
        try:
 
51
        with self.datafile(filename) as datafile:
53
52
            return datafile.readlines()
54
 
        finally:
55
 
            datafile.close()
56
53
 
57
54
    def test_parse_patches_leading_noise(self):
58
 
        # https://bugs.edge.launchpad.net/bzr/+bug/502076
59
 
        # https://code.edge.launchpad.net/~toshio/bzr/allow-dirty-patches/+merge/18854
60
 
        lines = ["diff -pruN commands.py",
61
 
            "--- orig/commands.py",
62
 
            "+++ mod/dommands.py"]
63
 
        bits = parse_patches(iter(lines), allow_dirty=True)
 
55
        # https://bugs.launchpad.net/bzr/+bug/502076
 
56
        # https://code.launchpad.net/~toshio/bzr/allow-dirty-patches/+merge/18854
 
57
        lines = [b"diff -pruN commands.py",
 
58
                 b"--- orig/commands.py",
 
59
                 b"+++ mod/dommands.py"]
 
60
        bits = list(parse_patches(iter(lines), allow_dirty=True))
 
61
 
 
62
    def test_preserve_dirty_head(self):
 
63
        """Parse a patch containing a dirty header, and preserve lines"""
 
64
        lines = [b"=== added directory 'foo/bar'\n",
 
65
                 b"=== modified file 'orig/commands.py'\n",
 
66
                 b"--- orig/commands.py\n",
 
67
                 b"+++ mod/dommands.py\n",
 
68
                 b"=== modified file 'orig/another.py'\n",
 
69
                 b"--- orig/another.py\n",
 
70
                 b"+++ mod/another.py\n"]
 
71
        patches = list(parse_patches(
 
72
            lines.__iter__(), allow_dirty=True, keep_dirty=True))
 
73
        self.assertLength(2, patches)
 
74
        self.assertEqual(patches[0]['dirty_head'],
 
75
                         [b"=== added directory 'foo/bar'\n",
 
76
                          b"=== modified file 'orig/commands.py'\n"])
 
77
        self.assertEqual(patches[0]['patch'].get_header().splitlines(True),
 
78
                         [b"--- orig/commands.py\n", b"+++ mod/dommands.py\n"])
 
79
        self.assertEqual(patches[1]['dirty_head'],
 
80
                         [b"=== modified file 'orig/another.py'\n"])
 
81
        self.assertEqual(patches[1]['patch'].get_header().splitlines(True),
 
82
                         [b"--- orig/another.py\n", b"+++ mod/another.py\n"])
64
83
 
65
84
    def testValidPatchHeader(self):
66
85
        """Parse a valid patch header"""
67
 
        lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
 
86
        lines = b"--- orig/commands.py\n+++ mod/dommands.py\n".split(b'\n')
68
87
        (orig, mod) = get_patch_names(lines.__iter__())
69
 
        self.assertEqual(orig, "orig/commands.py")
70
 
        self.assertEqual(mod, "mod/dommands.py")
 
88
        self.assertEqual(orig, b"orig/commands.py")
 
89
        self.assertEqual(mod, b"mod/dommands.py")
71
90
 
72
91
    def testInvalidPatchHeader(self):
73
92
        """Parse an invalid patch header"""
74
 
        lines = "-- orig/commands.py\n+++ mod/dommands.py".split('\n')
 
93
        lines = b"-- orig/commands.py\n+++ mod/dommands.py".split(b'\n')
75
94
        self.assertRaises(MalformedPatchHeader, get_patch_names,
76
95
                          lines.__iter__())
77
96
 
78
97
    def testValidHunkHeader(self):
79
98
        """Parse a valid hunk header"""
80
 
        header = "@@ -34,11 +50,6 @@\n"
81
 
        hunk = hunk_from_header(header);
 
99
        header = b"@@ -34,11 +50,6 @@\n"
 
100
        hunk = hunk_from_header(header)
82
101
        self.assertEqual(hunk.orig_pos, 34)
83
102
        self.assertEqual(hunk.orig_range, 11)
84
103
        self.assertEqual(hunk.mod_pos, 50)
85
104
        self.assertEqual(hunk.mod_range, 6)
86
 
        self.assertEqual(str(hunk), header)
 
105
        self.assertEqual(hunk.as_bytes(), header)
87
106
 
88
107
    def testValidHunkHeader2(self):
89
108
        """Parse a tricky, valid hunk header"""
90
 
        header = "@@ -1 +0,0 @@\n"
91
 
        hunk = hunk_from_header(header);
 
109
        header = b"@@ -1 +0,0 @@\n"
 
110
        hunk = hunk_from_header(header)
92
111
        self.assertEqual(hunk.orig_pos, 1)
93
112
        self.assertEqual(hunk.orig_range, 1)
94
113
        self.assertEqual(hunk.mod_pos, 0)
95
114
        self.assertEqual(hunk.mod_range, 0)
96
 
        self.assertEqual(str(hunk), header)
 
115
        self.assertEqual(hunk.as_bytes(), header)
97
116
 
98
117
    def testPDiff(self):
99
118
        """Parse a hunk header produced by diff -p"""
100
 
        header = "@@ -407,7 +292,7 @@ bzr 0.18rc1  2007-07-10\n"
 
119
        header = b"@@ -407,7 +292,7 @@ bzr 0.18rc1  2007-07-10\n"
101
120
        hunk = hunk_from_header(header)
102
 
        self.assertEqual('bzr 0.18rc1  2007-07-10', hunk.tail)
103
 
        self.assertEqual(header, str(hunk))
 
121
        self.assertEqual(b'bzr 0.18rc1  2007-07-10', hunk.tail)
 
122
        self.assertEqual(header, hunk.as_bytes())
104
123
 
105
124
    def makeMalformed(self, header):
106
125
        self.assertRaises(MalformedHunkHeader, hunk_from_header, header)
107
126
 
108
127
    def testInvalidHeader(self):
109
128
        """Parse an invalid hunk header"""
110
 
        self.makeMalformed(" -34,11 +50,6 \n")
111
 
        self.makeMalformed("@@ +50,6 -34,11 @@\n")
112
 
        self.makeMalformed("@@ -34,11 +50,6 @@")
113
 
        self.makeMalformed("@@ -34.5,11 +50,6 @@\n")
114
 
        self.makeMalformed("@@-34,11 +50,6@@\n")
115
 
        self.makeMalformed("@@ 34,11 50,6 @@\n")
116
 
        self.makeMalformed("@@ -34,11 @@\n")
117
 
        self.makeMalformed("@@ -34,11 +50,6.5 @@\n")
118
 
        self.makeMalformed("@@ -34,11 +50,-6 @@\n")
 
129
        self.makeMalformed(b" -34,11 +50,6 \n")
 
130
        self.makeMalformed(b"@@ +50,6 -34,11 @@\n")
 
131
        self.makeMalformed(b"@@ -34,11 +50,6 @@")
 
132
        self.makeMalformed(b"@@ -34.5,11 +50,6 @@\n")
 
133
        self.makeMalformed(b"@@-34,11 +50,6@@\n")
 
134
        self.makeMalformed(b"@@ 34,11 50,6 @@\n")
 
135
        self.makeMalformed(b"@@ -34,11 @@\n")
 
136
        self.makeMalformed(b"@@ -34,11 +50,6.5 @@\n")
 
137
        self.makeMalformed(b"@@ -34,11 +50,-6 @@\n")
119
138
 
120
 
    def lineThing(self,text, type):
 
139
    def lineThing(self, text, type):
121
140
        line = parse_line(text)
122
141
        self.assertIsInstance(line, type)
123
 
        self.assertEqual(str(line), text)
 
142
        self.assertEqual(line.as_bytes(), text)
124
143
 
125
144
    def makeMalformedLine(self, text):
126
145
        self.assertRaises(MalformedLine, parse_line, text)
127
146
 
128
147
    def testValidLine(self):
129
148
        """Parse a valid hunk line"""
130
 
        self.lineThing(" hello\n", ContextLine)
131
 
        self.lineThing("+hello\n", InsertLine)
132
 
        self.lineThing("-hello\n", RemoveLine)
 
149
        self.lineThing(b" hello\n", ContextLine)
 
150
        self.lineThing(b"+hello\n", InsertLine)
 
151
        self.lineThing(b"-hello\n", RemoveLine)
133
152
 
134
153
    def testMalformedLine(self):
135
154
        """Parse invalid valid hunk lines"""
136
 
        self.makeMalformedLine("hello\n")
 
155
        self.makeMalformedLine(b"hello\n")
137
156
 
138
157
    def testMalformedLineNO_NL(self):
139
 
        """Parse invalid '\ No newline at end of file' in hunk lines"""
 
158
        """Parse invalid '\\ No newline at end of file' in hunk lines"""
140
159
        self.makeMalformedLine(NO_NL)
141
160
 
142
161
    def compare_parsed(self, patchtext):
143
162
        lines = patchtext.splitlines(True)
144
163
        patch = parse_patch(lines.__iter__())
145
 
        pstr = str(patch)
 
164
        pstr = patch.as_bytes()
146
165
        i = difference_index(patchtext, pstr)
147
166
        if i is not None:
148
 
            print "%i: \"%s\" != \"%s\"" % (i, patchtext[i], pstr[i])
149
 
        self.assertEqual (patchtext, str(patch))
 
167
            print("%i: \"%s\" != \"%s\"" % (i, patchtext[i], pstr[i]))
 
168
        self.assertEqual(patchtext, patch.as_bytes())
150
169
 
151
170
    def testAll(self):
152
171
        """Test parsing a whole patch"""
153
 
        patchtext = self.datafile("patchtext.patch").read()
 
172
        with self.datafile("patchtext.patch") as f:
 
173
            patchtext = f.read()
154
174
        self.compare_parsed(patchtext)
155
175
 
156
176
    def test_parse_binary(self):
157
177
        """Test parsing a whole patch"""
158
 
        patches = parse_patches(self.data_lines("binary.patch"))
 
178
        patches = list(parse_patches(self.data_lines("binary.patch")))
159
179
        self.assertIs(BinaryPatch, patches[0].__class__)
160
180
        self.assertIs(Patch, patches[1].__class__)
161
 
        self.assertContainsRe(patches[0].oldname, '^bar\t')
162
 
        self.assertContainsRe(patches[0].newname, '^qux\t')
163
 
        self.assertContainsRe(str(patches[0]),
164
 
                                  'Binary files bar\t.* and qux\t.* differ\n')
 
181
        self.assertContainsRe(patches[0].oldname, b'^bar\t')
 
182
        self.assertContainsRe(patches[0].newname, b'^qux\t')
 
183
        self.assertContainsRe(patches[0].as_bytes(),
 
184
                              b'Binary files bar\t.* and qux\t.* differ\n')
165
185
 
166
186
    def test_parse_binary_after_normal(self):
167
 
        patches = parse_patches(self.data_lines("binary-after-normal.patch"))
 
187
        patches = list(parse_patches(self.data_lines("binary-after-normal.patch")))
168
188
        self.assertIs(BinaryPatch, patches[1].__class__)
169
189
        self.assertIs(Patch, patches[0].__class__)
170
 
        self.assertContainsRe(patches[1].oldname, '^bar\t')
171
 
        self.assertContainsRe(patches[1].newname, '^qux\t')
172
 
        self.assertContainsRe(str(patches[1]),
173
 
                                  'Binary files bar\t.* and qux\t.* differ\n')
 
190
        self.assertContainsRe(patches[1].oldname, b'^bar\t')
 
191
        self.assertContainsRe(patches[1].newname, b'^qux\t')
 
192
        self.assertContainsRe(patches[1].as_bytes(),
 
193
                              b'Binary files bar\t.* and qux\t.* differ\n')
174
194
 
175
195
    def test_roundtrip_binary(self):
176
 
        patchtext = ''.join(self.data_lines("binary.patch"))
 
196
        patchtext = b''.join(self.data_lines("binary.patch"))
177
197
        patches = parse_patches(patchtext.splitlines(True))
178
 
        self.assertEqual(patchtext, ''.join(str(p) for p in patches))
 
198
        self.assertEqual(patchtext, b''.join(p.as_bytes() for p in patches))
179
199
 
180
200
    def testInit(self):
181
201
        """Handle patches missing half the position, range tuple"""
182
202
        patchtext = \
183
 
"""--- orig/__vavg__.cl
 
203
b"""--- orig/__vavg__.cl
184
204
+++ mod/__vavg__.cl
185
205
@@ -1 +1,2 @@
186
206
 __qbpsbezng__ = "erfgehpgherqgrkg ra"
189
209
        self.compare_parsed(patchtext)
190
210
 
191
211
    def testLineLookup(self):
192
 
        import sys
193
212
        """Make sure we can accurately look up mod line from orig"""
194
213
        patch = parse_patch(self.datafile("diff"))
195
214
        orig = list(self.datafile("orig"))
205
224
        for hunk in patch.hunks:
206
225
            for line in hunk.lines:
207
226
                if isinstance(line, RemoveLine):
208
 
                    next = rem_iter.next()
209
 
                    if line.contents != next:
210
 
                        sys.stdout.write(" orig:%spatch:%s" % (next,
211
 
                                         line.contents))
212
 
                    self.assertEqual(line.contents, next)
213
 
        self.assertRaises(StopIteration, rem_iter.next)
 
227
                    self.assertEqual(line.contents, next(rem_iter))
 
228
        self.assertRaises(StopIteration, next, rem_iter)
214
229
 
215
230
    def testPatching(self):
216
231
        """Test a few patch files, and make sure they work."""
228
243
            mod_lines = list(self.datafile(mod))
229
244
 
230
245
            patched_file = IterableFile(iter_patched(orig_lines, patch))
231
 
            lines = []
232
246
            count = 0
233
247
            for patch_line in patched_file:
234
248
                self.assertEqual(patch_line, mod_lines[count])
239
253
        binary_lines = self.data_lines('binary.patch')
240
254
        e = self.assertRaises(BinaryFiles, iter_patched, [], binary_lines)
241
255
 
242
 
 
243
256
    def test_iter_patched_from_hunks(self):
244
257
        """Test a few patch files, and make sure they work."""
245
258
        files = [
256
269
            mod_lines = list(self.datafile(mod))
257
270
            iter_patched = iter_patched_from_hunks(orig_lines, parsed.hunks)
258
271
            patched_file = IterableFile(iter_patched)
259
 
            lines = []
260
272
            count = 0
261
273
            for patch_line in patched_file:
262
274
                self.assertEqual(patch_line, mod_lines[count])
271
283
    def testParsePatches(self):
272
284
        """Make sure file names can be extracted from tricky unified diffs"""
273
285
        patchtext = \
274
 
"""--- orig-7
 
286
b"""--- orig-7
275
287
+++ mod-7
276
288
@@ -1,10 +1,10 @@
277
289
 -- a
296
308
--- C
297
309
+++ D
298
310
"""
299
 
        filenames = [('orig-7', 'mod-7'),
300
 
                     ('orig-8', 'mod-8')]
 
311
        filenames = [(b'orig-7', b'mod-7'),
 
312
                     (b'orig-8', b'mod-8')]
301
313
        patches = parse_patches(patchtext.splitlines(True))
302
314
        patch_files = []
303
315
        for patch in patches: