/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-07-06 23:35:13 UTC
  • mto: (7027.3.2 python3-n)
  • mto: This revision was merged to the branch mainline in revision 7030.
  • Revision ID: jelmer@jelmer.uk-20180706233513-jcin71dp9ia1k11p
Port breezy.patches to Python3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_patches.py
48
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
55
        # https://bugs.launchpad.net/bzr/+bug/502076
59
56
        # https://code.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)
 
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))
64
61
 
65
62
    def test_preserve_dirty_head(self):
66
63
        """Parse a patch containing a dirty header, and preserve lines"""
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)
 
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))
76
73
        self.assertLength(2, patches)
77
74
        self.assertEqual(patches[0]['dirty_head'],
78
 
                         ["=== added directory 'foo/bar'\n",
79
 
                          "=== modified file 'orig/commands.py'\n"])
 
75
                         [b"=== added directory 'foo/bar'\n",
 
76
                          b"=== modified file 'orig/commands.py'\n"])
80
77
        self.assertEqual(patches[0]['patch'].get_header().splitlines(True),
81
 
                         ["--- orig/commands.py\n", "+++ mod/dommands.py\n"])
 
78
                         [b"--- orig/commands.py\n", b"+++ mod/dommands.py\n"])
82
79
        self.assertEqual(patches[1]['dirty_head'],
83
 
                         ["=== modified file 'orig/another.py'\n"])
 
80
                         [b"=== modified file 'orig/another.py'\n"])
84
81
        self.assertEqual(patches[1]['patch'].get_header().splitlines(True),
85
 
                         ["--- orig/another.py\n", "+++ mod/another.py\n"])
 
82
                         [b"--- orig/another.py\n", b"+++ mod/another.py\n"])
86
83
 
87
84
    def testValidPatchHeader(self):
88
85
        """Parse a valid patch header"""
89
 
        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')
90
87
        (orig, mod) = get_patch_names(lines.__iter__())
91
 
        self.assertEqual(orig, "orig/commands.py")
92
 
        self.assertEqual(mod, "mod/dommands.py")
 
88
        self.assertEqual(orig, b"orig/commands.py")
 
89
        self.assertEqual(mod, b"mod/dommands.py")
93
90
 
94
91
    def testInvalidPatchHeader(self):
95
92
        """Parse an invalid patch header"""
96
 
        lines = "-- orig/commands.py\n+++ mod/dommands.py".split('\n')
 
93
        lines = b"-- orig/commands.py\n+++ mod/dommands.py".split(b'\n')
97
94
        self.assertRaises(MalformedPatchHeader, get_patch_names,
98
95
                          lines.__iter__())
99
96
 
100
97
    def testValidHunkHeader(self):
101
98
        """Parse a valid hunk header"""
102
 
        header = "@@ -34,11 +50,6 @@\n"
 
99
        header = b"@@ -34,11 +50,6 @@\n"
103
100
        hunk = hunk_from_header(header)
104
101
        self.assertEqual(hunk.orig_pos, 34)
105
102
        self.assertEqual(hunk.orig_range, 11)
106
103
        self.assertEqual(hunk.mod_pos, 50)
107
104
        self.assertEqual(hunk.mod_range, 6)
108
 
        self.assertEqual(str(hunk), header)
 
105
        self.assertEqual(bytes(hunk), header)
109
106
 
110
107
    def testValidHunkHeader2(self):
111
108
        """Parse a tricky, valid hunk header"""
112
 
        header = "@@ -1 +0,0 @@\n"
 
109
        header = b"@@ -1 +0,0 @@\n"
113
110
        hunk = hunk_from_header(header)
114
111
        self.assertEqual(hunk.orig_pos, 1)
115
112
        self.assertEqual(hunk.orig_range, 1)
116
113
        self.assertEqual(hunk.mod_pos, 0)
117
114
        self.assertEqual(hunk.mod_range, 0)
118
 
        self.assertEqual(str(hunk), header)
 
115
        self.assertEqual(bytes(hunk), header)
119
116
 
120
117
    def testPDiff(self):
121
118
        """Parse a hunk header produced by diff -p"""
122
 
        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"
123
120
        hunk = hunk_from_header(header)
124
 
        self.assertEqual('bzr 0.18rc1  2007-07-10', hunk.tail)
125
 
        self.assertEqual(header, str(hunk))
 
121
        self.assertEqual(b'bzr 0.18rc1  2007-07-10', hunk.tail)
 
122
        self.assertEqual(header, bytes(hunk))
126
123
 
127
124
    def makeMalformed(self, header):
128
125
        self.assertRaises(MalformedHunkHeader, hunk_from_header, header)
129
126
 
130
127
    def testInvalidHeader(self):
131
128
        """Parse an invalid hunk header"""
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")
 
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")
141
138
 
142
139
    def lineThing(self, text, type):
143
140
        line = parse_line(text)
144
141
        self.assertIsInstance(line, type)
145
 
        self.assertEqual(str(line), text)
 
142
        self.assertEqual(bytes(line), text)
146
143
 
147
144
    def makeMalformedLine(self, text):
148
145
        self.assertRaises(MalformedLine, parse_line, text)
149
146
 
150
147
    def testValidLine(self):
151
148
        """Parse a valid hunk line"""
152
 
        self.lineThing(" hello\n", ContextLine)
153
 
        self.lineThing("+hello\n", InsertLine)
154
 
        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)
155
152
 
156
153
    def testMalformedLine(self):
157
154
        """Parse invalid valid hunk lines"""
158
 
        self.makeMalformedLine("hello\n")
 
155
        self.makeMalformedLine(b"hello\n")
159
156
 
160
157
    def testMalformedLineNO_NL(self):
161
158
        """Parse invalid '\\ No newline at end of file' in hunk lines"""
164
161
    def compare_parsed(self, patchtext):
165
162
        lines = patchtext.splitlines(True)
166
163
        patch = parse_patch(lines.__iter__())
167
 
        pstr = str(patch)
 
164
        pstr = bytes(patch)
168
165
        i = difference_index(patchtext, pstr)
169
166
        if i is not None:
170
167
            print("%i: \"%s\" != \"%s\"" % (i, patchtext[i], pstr[i]))
171
 
        self.assertEqual(patchtext, str(patch))
 
168
        self.assertEqual(patchtext, bytes(patch))
172
169
 
173
170
    def testAll(self):
174
171
        """Test parsing a whole patch"""
175
 
        patchtext = self.datafile("patchtext.patch").read()
 
172
        with self.datafile("patchtext.patch") as f:
 
173
            patchtext = f.read()
176
174
        self.compare_parsed(patchtext)
177
175
 
178
176
    def test_parse_binary(self):
179
177
        """Test parsing a whole patch"""
180
 
        patches = parse_patches(self.data_lines("binary.patch"))
 
178
        patches = list(parse_patches(self.data_lines("binary.patch")))
181
179
        self.assertIs(BinaryPatch, patches[0].__class__)
182
180
        self.assertIs(Patch, patches[1].__class__)
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')
 
181
        self.assertContainsRe(patches[0].oldname, b'^bar\t')
 
182
        self.assertContainsRe(patches[0].newname, b'^qux\t')
 
183
        self.assertContainsRe(bytes(patches[0]),
 
184
                              b'Binary files bar\t.* and qux\t.* differ\n')
187
185
 
188
186
    def test_parse_binary_after_normal(self):
189
 
        patches = parse_patches(self.data_lines("binary-after-normal.patch"))
 
187
        patches = list(parse_patches(self.data_lines("binary-after-normal.patch")))
190
188
        self.assertIs(BinaryPatch, patches[1].__class__)
191
189
        self.assertIs(Patch, patches[0].__class__)
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')
 
190
        self.assertContainsRe(patches[1].oldname, b'^bar\t')
 
191
        self.assertContainsRe(patches[1].newname, b'^qux\t')
 
192
        self.assertContainsRe(bytes(patches[1]),
 
193
                              b'Binary files bar\t.* and qux\t.* differ\n')
196
194
 
197
195
    def test_roundtrip_binary(self):
198
 
        patchtext = ''.join(self.data_lines("binary.patch"))
 
196
        patchtext = b''.join(self.data_lines("binary.patch"))
199
197
        patches = parse_patches(patchtext.splitlines(True))
200
 
        self.assertEqual(patchtext, ''.join(str(p) for p in patches))
 
198
        self.assertEqual(patchtext, b''.join(bytes(p) for p in patches))
201
199
 
202
200
    def testInit(self):
203
201
        """Handle patches missing half the position, range tuple"""
204
202
        patchtext = \
205
 
"""--- orig/__vavg__.cl
 
203
b"""--- orig/__vavg__.cl
206
204
+++ mod/__vavg__.cl
207
205
@@ -1 +1,2 @@
208
206
 __qbpsbezng__ = "erfgehpgherqgrkg ra"
285
283
    def testParsePatches(self):
286
284
        """Make sure file names can be extracted from tricky unified diffs"""
287
285
        patchtext = \
288
 
"""--- orig-7
 
286
b"""--- orig-7
289
287
+++ mod-7
290
288
@@ -1,10 +1,10 @@
291
289
 -- a
310
308
--- C
311
309
+++ D
312
310
"""
313
 
        filenames = [('orig-7', 'mod-7'),
314
 
                     ('orig-8', 'mod-8')]
 
311
        filenames = [(b'orig-7', b'mod-7'),
 
312
                     (b'orig-8', b'mod-8')]
315
313
        patches = parse_patches(patchtext.splitlines(True))
316
314
        patch_files = []
317
315
        for patch in patches: