/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_merge_directive.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_merge_directive.py
26
26
    )
27
27
 
28
28
 
29
 
OUTPUT1 = b"""# Bazaar merge directive format 1
 
29
OUTPUT1 = """# Bazaar merge directive format 1
30
30
# revision_id: example:
31
31
# target_branch: http://example.com
32
32
# testament_sha1: sha
34
34
#\x20
35
35
booga"""
36
36
 
37
 
OUTPUT1_2 = b"""# Bazaar merge directive format 2 (Bazaar 0.90)
 
37
OUTPUT1_2 = """# Bazaar merge directive format 2 (Bazaar 0.90)
38
38
# revision_id: example:
39
39
# target_branch: http://example.com
40
40
# testament_sha1: sha
44
44
# Begin bundle
45
45
booga"""
46
46
 
47
 
OUTPUT2 = b"""# Bazaar merge directive format 1
 
47
OUTPUT2 = """# Bazaar merge directive format 1
48
48
# revision_id: example:
49
49
# target_branch: http://example.com
50
50
# testament_sha1: sha
54
54
#\x20
55
55
booga"""
56
56
 
57
 
OUTPUT2_2 = b"""# Bazaar merge directive format 2 (Bazaar 0.90)
 
57
OUTPUT2_2 = """# Bazaar merge directive format 2 (Bazaar 0.90)
58
58
# revision_id: example:
59
59
# target_branch: http://example.com
60
60
# testament_sha1: sha
66
66
# Begin patch
67
67
booga"""
68
68
 
69
 
INPUT1 = b"""
 
69
INPUT1 = """
70
70
I was thinking today about creating a merge directive.
71
71
 
72
72
So I did.
88
88
booga""".splitlines(True)
89
89
 
90
90
 
91
 
INPUT1_2 = b"""
 
91
INPUT1_2 = """
92
92
I was thinking today about creating a merge directive.
93
93
 
94
94
So I did.
112
112
booga""".splitlines(True)
113
113
 
114
114
 
115
 
INPUT1_2_OLD = b"""
 
115
INPUT1_2_OLD = """
116
116
I was thinking today about creating a merge directive.
117
117
 
118
118
So I did.
136
136
booga""".splitlines(True)
137
137
 
138
138
 
139
 
OLD_DIRECTIVE_2 = b"""# Bazaar merge directive format 2 (Bazaar 0.19)
 
139
OLD_DIRECTIVE_2 = """# Bazaar merge directive format 2 (Bazaar 0.19)
140
140
# revision_id: abentley@panoramicfeedback.com-20070807234458-\
141
141
#   nzhkoyza56lan7z5
142
142
# target_branch: http://panoramicfeedback.com/opensource/bzr/repo\
157
157
        time = 500000.0
158
158
        timezone = 5 * 3600
159
159
        self.assertRaises(errors.NoMergeSource, self.make_merge_directive,
160
 
                          b'example:', b'sha', time, timezone, 'http://example.com')
 
160
            'example:', 'sha', time, timezone, 'http://example.com')
161
161
        self.assertRaises(errors.NoMergeSource, self.make_merge_directive,
162
 
                          b'example:', b'sha', time, timezone, 'http://example.com',
163
 
                          patch_type='diff')
164
 
        self.make_merge_directive(b'example:', b'sha', time, timezone,
165
 
                                  'http://example.com', source_branch='http://example.org')
166
 
        md = self.make_merge_directive(b'null:', b'sha', time, timezone,
167
 
                                       'http://example.com', patch=b'blah', patch_type='bundle')
 
162
            'example:', 'sha', time, timezone, 'http://example.com',
 
163
            patch_type='diff')
 
164
        self.make_merge_directive('example:', 'sha', time, timezone,
 
165
            'http://example.com', source_branch='http://example.org')
 
166
        md = self.make_merge_directive('null:', 'sha', time, timezone,
 
167
            'http://example.com', patch='blah', patch_type='bundle')
168
168
        self.assertIs(None, md.source_branch)
169
 
        md2 = self.make_merge_directive(b'null:', b'sha', time, timezone,
170
 
                                        'http://example.com', patch=b'blah', patch_type='bundle',
171
 
                                        source_branch='bar')
 
169
        md2 = self.make_merge_directive('null:', 'sha', time, timezone,
 
170
            'http://example.com', patch='blah', patch_type='bundle',
 
171
            source_branch='bar')
172
172
        self.assertEqual('bar', md2.source_branch)
173
173
 
174
174
    def test_serialization(self):
175
175
        time = 453
176
176
        timezone = 120
177
 
        md = self.make_merge_directive(b'example:', b'sha', time, timezone,
178
 
                                       'http://example.com', patch=b'booga', patch_type='bundle')
179
 
        self.assertEqualDiff(self.OUTPUT1, b''.join(md.to_lines()))
180
 
        md = self.make_merge_directive(b'example:', b'sha', time, timezone,
181
 
                                       'http://example.com', source_branch="http://example.org",
182
 
                                       patch=b'booga', patch_type='diff', message="Hi mom!")
183
 
        self.assertEqualDiff(self.OUTPUT2, b''.join(md.to_lines()))
 
177
        md = self.make_merge_directive('example:', 'sha', time, timezone,
 
178
            'http://example.com', patch='booga', patch_type='bundle')
 
179
        self.assertEqualDiff(self.OUTPUT1, ''.join(md.to_lines()))
 
180
        md = self.make_merge_directive('example:', 'sha', time, timezone,
 
181
            'http://example.com', source_branch="http://example.org",
 
182
            patch='booga', patch_type='diff', message="Hi mom!")
 
183
        self.assertEqualDiff(self.OUTPUT2, ''.join(md.to_lines()))
184
184
 
185
185
    def test_deserialize_junk(self):
186
186
        time = 501
187
187
        self.assertRaises(errors.NotAMergeDirective,
188
 
                          merge_directive.MergeDirective.from_lines, [b'lala'])
 
188
                          merge_directive.MergeDirective.from_lines, 'lala')
189
189
 
190
190
    def test_deserialize_empty(self):
191
191
        self.assertRaises(errors.NotAMergeDirective,
193
193
 
194
194
    def test_deserialize_leading_junk(self):
195
195
        md = merge_directive.MergeDirective.from_lines(self.INPUT1)
196
 
        self.assertEqual(b'example:', md.revision_id)
197
 
        self.assertEqual(b'sha', md.testament_sha1)
 
196
        self.assertEqual('example:', md.revision_id)
 
197
        self.assertEqual('sha', md.testament_sha1)
198
198
        self.assertEqual('http://example.com', md.target_branch)
199
199
        self.assertEqual('http://example.org', md.source_branch)
200
200
        self.assertEqual(453, md.time)
201
201
        self.assertEqual(120, md.timezone)
202
 
        self.assertEqual(b'booga', md.patch)
 
202
        self.assertEqual('booga', md.patch)
203
203
        self.assertEqual('diff', md.patch_type)
204
204
        self.assertEqual('Hi mom!', md.message)
205
205
 
206
206
    def test_roundtrip(self):
207
207
        time = 500000
208
208
        timezone = 7.5 * 3600
209
 
        md = self.make_merge_directive(b'example:', b'sha', time, timezone,
210
 
                                       'http://example.com', source_branch="http://example.org",
211
 
                                       patch=b'booga', patch_type='diff')
 
209
        md = self.make_merge_directive('example:', 'sha', time, timezone,
 
210
            'http://example.com', source_branch="http://example.org",
 
211
            patch='booga', patch_type='diff')
212
212
        md2 = merge_directive.MergeDirective.from_lines(md.to_lines())
213
 
        self.assertEqual(b'example:', md2.revision_id)
214
 
        self.assertIsInstance(md2.revision_id, bytes)
215
 
        self.assertEqual(b'sha', md2.testament_sha1)
 
213
        self.assertEqual('example:', md2.revision_id)
 
214
        self.assertIsInstance(md2.revision_id, str)
 
215
        self.assertEqual('sha', md2.testament_sha1)
216
216
        self.assertEqual('http://example.com', md2.target_branch)
217
217
        self.assertEqual('http://example.org', md2.source_branch)
218
218
        self.assertEqual(time, md2.time)
219
219
        self.assertEqual(timezone, md2.timezone)
220
220
        self.assertEqual('diff', md2.patch_type)
221
 
        self.assertEqual(b'booga', md2.patch)
 
221
        self.assertEqual('booga', md2.patch)
222
222
        self.assertEqual(None, md2.message)
223
 
        self.set_bundle(md, b"# Bazaar revision bundle v0.9\n#\n")
 
223
        self.set_bundle(md, "# Bazaar revision bundle v0.9\n#\n")
224
224
        md.message = "Hi mom!"
225
225
        lines = md.to_lines()
226
226
        md3 = merge_directive.MergeDirective.from_lines(lines)
227
 
        self.assertEqual(b"# Bazaar revision bundle v0.9\n#\n", md3.bundle)
 
227
        self.assertEqual("# Bazaar revision bundle v0.9\n#\n", md3.bundle)
228
228
        self.assertEqual("bundle", md3.patch_type)
229
229
        self.assertContainsRe(md3.to_lines()[0],
230
 
                              b'^# Bazaar merge directive format ')
 
230
            '^# Bazaar merge directive format ')
231
231
        self.assertEqual("Hi mom!", md3.message)
232
232
        md3.clear_payload()
233
233
        self.assertIs(None, md3.get_raw_bundle())
245
245
    OUTPUT2 = OUTPUT2
246
246
 
247
247
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
248
 
                             target_branch, patch=None, patch_type=None,
249
 
                             source_branch=None, message=None):
 
248
                 target_branch, patch=None, patch_type=None,
 
249
                 source_branch=None, message=None):
250
250
        return merge_directive.MergeDirective(revision_id, testament_sha1,
251
 
                                              time, timezone, target_branch, patch, patch_type,
252
 
                                              source_branch, message)
 
251
                 time, timezone, target_branch, patch, patch_type,
 
252
                 source_branch, message)
253
253
 
254
254
    @staticmethod
255
255
    def set_bundle(md, value):
259
259
        time = 500.0
260
260
        timezone = 120
261
261
        self.assertRaises(errors.PatchMissing, merge_directive.MergeDirective,
262
 
                          b'example:', b'sha', time, timezone, 'http://example.com',
263
 
                          patch_type='bundle')
264
 
        md = merge_directive.MergeDirective(b'example:', b'sha1', time, timezone,
265
 
                                            'http://example.com', source_branch="http://example.org",
266
 
                                            patch=b'', patch_type='diff')
267
 
        self.assertEqual(md.patch, b'')
 
262
            'example:', 'sha', time, timezone, 'http://example.com',
 
263
            patch_type='bundle')
 
264
        md = merge_directive.MergeDirective('example:', 'sha1', time, timezone,
 
265
            'http://example.com', source_branch="http://example.org",
 
266
            patch='', patch_type='diff')
 
267
        self.assertEqual(md.patch, '')
268
268
 
269
269
 
270
270
class TestMergeDirective2(tests.TestCase, TestMergeDirective):
277
277
    OUTPUT2 = OUTPUT2_2
278
278
 
279
279
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
280
 
                             target_branch, patch=None, patch_type=None,
281
 
                             source_branch=None, message=None, base_revision_id=b'null:'):
 
280
                 target_branch, patch=None, patch_type=None,
 
281
                 source_branch=None, message=None, base_revision_id='null:'):
282
282
        if patch_type == 'bundle':
283
283
            bundle = patch
284
284
            patch = None
285
285
        else:
286
286
            bundle = None
287
287
        return merge_directive.MergeDirective2(revision_id, testament_sha1,
288
 
                                               time, timezone, target_branch, patch, source_branch, message,
289
 
                                               bundle, base_revision_id)
 
288
            time, timezone, target_branch, patch, source_branch, message,
 
289
            bundle, base_revision_id)
290
290
 
291
291
    @staticmethod
292
292
    def set_bundle(md, value):
296
296
EMAIL1 = """From: "J. Random Hacker" <jrandom@example.com>
297
297
Subject: Commit of rev2a
298
298
To: pqm@example.com
299
 
User-Agent: Bazaar \\(.*\\)
 
299
User-Agent: Bazaar \(.*\)
300
300
 
301
301
# Bazaar merge directive format 1
302
302
# revision_id: rev2a
310
310
EMAIL1_2 = """From: "J. Random Hacker" <jrandom@example.com>
311
311
Subject: Commit of rev2a
312
312
To: pqm@example.com
313
 
User-Agent: Bazaar \\(.*\\)
 
313
User-Agent: Bazaar \(.*\)
314
314
 
315
315
# Bazaar merge directive format 2 \\(Bazaar 0.90\\)
316
316
# revision_id: rev2a
324
324
EMAIL2 = """From: "J. Random Hacker" <jrandom@example.com>
325
325
Subject: Commit of rev2a with special message
326
326
To: pqm@example.com
327
 
User-Agent: Bazaar \\(.*\\)
 
327
User-Agent: Bazaar \(.*\)
328
328
 
329
329
# Bazaar merge directive format 1
330
330
# revision_id: rev2a
338
338
EMAIL2_2 = """From: "J. Random Hacker" <jrandom@example.com>
339
339
Subject: Commit of rev2a with special message
340
340
To: pqm@example.com
341
 
User-Agent: Bazaar \\(.*\\)
 
341
User-Agent: Bazaar \(.*\)
342
342
 
343
343
# Bazaar merge directive format 2 \\(Bazaar 0.90\\)
344
344
# revision_id: rev2a
349
349
# message: Commit of rev2a with special message
350
350
"""
351
351
 
352
 
 
353
352
class TestMergeDirectiveBranch(object):
354
353
 
355
354
    def make_trees(self):
356
355
        tree_a = self.make_branch_and_tree('tree_a')
357
356
        tree_a.branch.get_config_stack().set(
358
357
            'email', 'J. Random Hacker <jrandom@example.com>')
359
 
        self.build_tree_contents([('tree_a/file', b'content_a\ncontent_b\n'),
360
 
                                  ('tree_a/file_2', b'content_x\rcontent_y\r')])
 
358
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_b\n'),
 
359
                                  ('tree_a/file_2', 'content_x\rcontent_y\r')])
361
360
        tree_a.add(['file', 'file_2'])
362
 
        tree_a.commit('message', rev_id=b'rev1')
 
361
        tree_a.commit('message', rev_id='rev1')
363
362
        tree_b = tree_a.controldir.sprout('tree_b').open_workingtree()
364
363
        branch_c = tree_a.controldir.sprout('branch_c').open_branch()
365
 
        tree_b.commit('message', rev_id=b'rev2b')
366
 
        self.build_tree_contents([('tree_a/file', b'content_a\ncontent_c \n'),
367
 
                                  ('tree_a/file_2', b'content_x\rcontent_z\r')])
368
 
        tree_a.commit('Commit of rev2a', rev_id=b'rev2a')
 
364
        tree_b.commit('message', rev_id='rev2b')
 
365
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_c \n'),
 
366
                                  ('tree_a/file_2', 'content_x\rcontent_z\r')])
 
367
        tree_a.commit('Commit of rev2a', rev_id='rev2a')
369
368
        return tree_a, tree_b, branch_c
370
369
 
371
370
    def test_empty_target(self):
372
371
        tree_a, tree_b, branch_c = self.make_trees()
373
372
        tree_d = self.make_branch_and_tree('tree_d')
374
 
        md2 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 120,
375
 
                                tree_d.branch.base, patch_type='diff',
376
 
                                public_branch=tree_a.branch.base)
 
373
        md2 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
 
374
            tree_d.branch.base, patch_type='diff',
 
375
            public_branch=tree_a.branch.base)
377
376
 
378
377
    def test_disk_name(self):
379
378
        tree_a, tree_b, branch_c = self.make_trees()
380
379
        tree_a.branch.nick = 'fancy <name>'
381
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 120,
382
 
                               tree_b.branch.base)
 
380
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
 
381
            tree_b.branch.base)
383
382
        self.assertEqual('fancy-name-2', md.get_disk_name(tree_a.branch))
384
383
 
385
384
    def test_disk_name_old_revno(self):
386
385
        tree_a, tree_b, branch_c = self.make_trees()
387
386
        tree_a.branch.nick = 'fancy-name'
388
 
        md = self.from_objects(tree_a.branch.repository, b'rev1', 500, 120,
389
 
                               tree_b.branch.base)
 
387
        md = self.from_objects(tree_a.branch.repository, 'rev1', 500, 120,
 
388
            tree_b.branch.base)
390
389
        self.assertEqual('fancy-name-1', md.get_disk_name(tree_a.branch))
391
390
 
392
391
    def test_generate_patch(self):
393
392
        tree_a, tree_b, branch_c = self.make_trees()
394
 
        md2 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 120,
395
 
                                tree_b.branch.base, patch_type='diff',
396
 
                                public_branch=tree_a.branch.base)
397
 
        self.assertNotContainsRe(md2.patch, b'Bazaar revision bundle')
398
 
        self.assertContainsRe(md2.patch, b'\\+content_c')
399
 
        self.assertNotContainsRe(md2.patch, b'\\+\\+\\+ b/')
400
 
        self.assertContainsRe(md2.patch, b'\\+\\+\\+ file')
 
393
        md2 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
 
394
            tree_b.branch.base, patch_type='diff',
 
395
            public_branch=tree_a.branch.base)
 
396
        self.assertNotContainsRe(md2.patch, 'Bazaar revision bundle')
 
397
        self.assertContainsRe(md2.patch, '\\+content_c')
 
398
        self.assertNotContainsRe(md2.patch, '\\+\\+\\+ b/')
 
399
        self.assertContainsRe(md2.patch, '\\+\\+\\+ file')
401
400
 
402
401
    def test_public_branch(self):
403
402
        tree_a, tree_b, branch_c = self.make_trees()
404
403
        self.assertRaises(errors.PublicBranchOutOfDate,
405
 
                          self.from_objects, tree_a.branch.repository, b'rev2a', 500, 144,
406
 
                          tree_b.branch.base, public_branch=branch_c.base, patch_type='diff')
 
404
            self.from_objects, tree_a.branch.repository, 'rev2a', 500, 144,
 
405
            tree_b.branch.base, public_branch=branch_c.base, patch_type='diff')
407
406
        self.assertRaises(errors.PublicBranchOutOfDate,
408
 
                          self.from_objects, tree_a.branch.repository, b'rev2a', 500, 144,
409
 
                          tree_b.branch.base, public_branch=branch_c.base, patch_type=None)
 
407
            self.from_objects, tree_a.branch.repository, 'rev2a', 500, 144,
 
408
            tree_b.branch.base, public_branch=branch_c.base, patch_type=None)
410
409
        # public branch is not checked if patch format is bundle.
411
 
        md1 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 144,
412
 
                                tree_b.branch.base, public_branch=branch_c.base)
 
410
        md1 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 144,
 
411
            tree_b.branch.base, public_branch=branch_c.base)
413
412
        # public branch is provided with a bundle, despite possibly being out
414
413
        # of date, because it's not required if a bundle is present.
415
414
        self.assertEqual(md1.source_branch, branch_c.base)
416
415
        # Once we update the public branch, we can generate a diff.
417
416
        branch_c.pull(tree_a.branch)
418
 
        md3 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 144,
419
 
                                tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
 
417
        md3 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 144,
 
418
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
420
419
 
421
420
    def test_use_public_submit_branch(self):
422
421
        tree_a, tree_b, branch_c = self.make_trees()
423
422
        branch_c.pull(tree_a.branch)
424
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 144,
425
 
                               tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
 
423
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 144,
 
424
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
426
425
        self.assertEqual(md.target_branch, tree_b.branch.base)
427
426
        tree_b.branch.set_public_branch('http://example.com')
428
427
        md2 = self.from_objects(
429
 
            tree_a.branch.repository, b'rev2a', 500, 144, tree_b.branch.base,
430
 
            patch_type=None, public_branch=branch_c.base)
 
428
              tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
429
              patch_type=None, public_branch=branch_c.base)
431
430
        self.assertEqual(md2.target_branch, 'http://example.com')
432
431
 
433
432
    def test_message(self):
434
433
        tree_a, tree_b, branch_c = self.make_trees()
435
 
        md3 = self.from_objects(tree_a.branch.repository, b'rev1', 500, 120,
436
 
                                tree_b.branch.base, patch_type=None, public_branch=branch_c.base,
437
 
                                message='Merge message')
 
434
        md3 = self.from_objects(tree_a.branch.repository, 'rev1', 500, 120,
 
435
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base,
 
436
            message='Merge message')
438
437
        md3.to_lines()
439
438
        self.assertIs(None, md3.patch)
440
439
        self.assertEqual('Merge message', md3.message)
441
440
 
442
441
    def test_generate_bundle(self):
443
442
        tree_a, tree_b, branch_c = self.make_trees()
444
 
        md1 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 120,
445
 
                                tree_b.branch.base, public_branch=branch_c.base)
 
443
        md1 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
 
444
            tree_b.branch.base, public_branch=branch_c.base)
446
445
 
447
 
        self.assertContainsRe(md1.get_raw_bundle(), b'Bazaar revision bundle')
448
 
        self.assertContainsRe(md1.patch, b'\\+content_c')
449
 
        self.assertNotContainsRe(md1.patch, b'\\+content_a')
450
 
        self.assertContainsRe(md1.patch, b'\\+content_c')
451
 
        self.assertNotContainsRe(md1.patch, b'\\+content_a')
 
446
        self.assertContainsRe(md1.get_raw_bundle(), 'Bazaar revision bundle')
 
447
        self.assertContainsRe(md1.patch, '\\+content_c')
 
448
        self.assertNotContainsRe(md1.patch, '\\+content_a')
 
449
        self.assertContainsRe(md1.patch, '\\+content_c')
 
450
        self.assertNotContainsRe(md1.patch, '\\+content_a')
452
451
 
453
452
    def test_broken_bundle(self):
454
453
        tree_a, tree_b, branch_c = self.make_trees()
455
 
        md1 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 120,
456
 
                                tree_b.branch.base, public_branch=branch_c.base)
 
454
        md1 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
 
455
            tree_b.branch.base, public_branch=branch_c.base)
457
456
        lines = md1.to_lines()
458
 
        lines = [l.replace(b'\n', b'\r\n') for l in lines]
 
457
        lines = [l.replace('\n', '\r\n') for l in lines]
459
458
        md2 = merge_directive.MergeDirective.from_lines(lines)
460
 
        self.assertEqual(b'rev2a', md2.revision_id)
 
459
        self.assertEqual('rev2a', md2.revision_id)
461
460
 
462
461
    def test_signing(self):
463
462
        time = 453
464
463
        timezone = 7200
465
 
 
466
464
        class FakeBranch(object):
467
465
            def get_config_stack(self):
468
466
                return self
469
 
        md = self.make_merge_directive(b'example:', b'sha', time, timezone,
470
 
                                       'http://example.com', source_branch="http://example.org",
471
 
                                       patch=b'booga', patch_type='diff')
 
467
        md = self.make_merge_directive('example:', 'sha', time, timezone,
 
468
            'http://example.com', source_branch="http://example.org",
 
469
            patch='booga', patch_type='diff')
472
470
        old_strategy = gpg.GPGStrategy
473
471
        gpg.GPGStrategy = gpg.LoopbackGPGStrategy
474
472
        try:
475
473
            signed = md.to_signed(FakeBranch())
476
474
        finally:
477
475
            gpg.GPGStrategy = old_strategy
478
 
        self.assertContainsRe(signed, b'^-----BEGIN PSEUDO-SIGNED CONTENT')
479
 
        self.assertContainsRe(signed, b'example.org')
480
 
        self.assertContainsRe(signed, b'booga')
 
476
        self.assertContainsRe(signed, '^-----BEGIN PSEUDO-SIGNED CONTENT')
 
477
        self.assertContainsRe(signed, 'example.org')
 
478
        self.assertContainsRe(signed, 'booga')
481
479
 
482
480
    def test_email(self):
483
481
        tree_a, tree_b, branch_c = self.make_trees()
484
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 476, 60,
485
 
                               tree_b.branch.base, patch_type=None,
486
 
                               public_branch=tree_a.branch.base)
 
482
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 476, 60,
 
483
            tree_b.branch.base, patch_type=None,
 
484
            public_branch=tree_a.branch.base)
487
485
        message = md.to_email('pqm@example.com', tree_a.branch)
488
486
        self.assertContainsRe(message.as_string(), self.EMAIL1)
489
487
        md.message = 'Commit of rev2a with special message'
492
490
 
493
491
    def test_install_revisions_branch(self):
494
492
        tree_a, tree_b, branch_c = self.make_trees()
495
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 36,
496
 
                               tree_b.branch.base, patch_type=None,
497
 
                               public_branch=tree_a.branch.base)
498
 
        self.assertFalse(tree_b.branch.repository.has_revision(b'rev2a'))
 
493
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
 
494
            tree_b.branch.base, patch_type=None,
 
495
            public_branch=tree_a.branch.base)
 
496
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
499
497
        revision = md.install_revisions(tree_b.branch.repository)
500
 
        self.assertEqual(b'rev2a', revision)
501
 
        self.assertTrue(tree_b.branch.repository.has_revision(b'rev2a'))
 
498
        self.assertEqual('rev2a', revision)
 
499
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
502
500
 
503
501
    def test_get_merge_request(self):
504
502
        tree_a, tree_b, branch_c = self.make_trees()
505
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 36,
506
 
                               tree_b.branch.base, patch_type='bundle',
507
 
                               public_branch=tree_a.branch.base)
508
 
        self.assertFalse(tree_b.branch.repository.has_revision(b'rev2a'))
 
503
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
 
504
            tree_b.branch.base, patch_type='bundle',
 
505
            public_branch=tree_a.branch.base)
 
506
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
509
507
        md.install_revisions(tree_b.branch.repository)
510
508
        base, revision, verified = md.get_merge_request(
511
509
            tree_b.branch.repository)
513
511
            self.assertIs(None, base)
514
512
            self.assertEqual('inapplicable', verified)
515
513
        else:
516
 
            self.assertEqual(b'rev1', base)
517
 
            self.assertEqual('verified', verified)
518
 
        self.assertEqual(b'rev2a', revision)
519
 
        self.assertTrue(tree_b.branch.repository.has_revision(b'rev2a'))
520
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 36,
521
 
                               tree_b.branch.base, patch_type=None,
522
 
                               public_branch=tree_a.branch.base)
523
 
        base, revision, verified = md.get_merge_request(
524
 
            tree_b.branch.repository)
525
 
        if isinstance(md, merge_directive.MergeDirective):
526
 
            self.assertIs(None, base)
527
 
            self.assertEqual('inapplicable', verified)
528
 
        else:
529
 
            self.assertEqual(b'rev1', base)
530
 
            self.assertEqual('inapplicable', verified)
531
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 36,
532
 
                               tree_b.branch.base, patch_type='diff',
533
 
                               public_branch=tree_a.branch.base)
534
 
        base, revision, verified = md.get_merge_request(
535
 
            tree_b.branch.repository)
536
 
        if isinstance(md, merge_directive.MergeDirective):
537
 
            self.assertIs(None, base)
538
 
            self.assertEqual('inapplicable', verified)
539
 
        else:
540
 
            self.assertEqual(b'rev1', base)
541
 
            self.assertEqual('verified', verified)
542
 
        md.patch = b'asdf'
543
 
        base, revision, verified = md.get_merge_request(
544
 
            tree_b.branch.repository)
545
 
        if isinstance(md, merge_directive.MergeDirective):
546
 
            self.assertIs(None, base)
547
 
            self.assertEqual('inapplicable', verified)
548
 
        else:
549
 
            self.assertEqual(b'rev1', base)
 
514
            self.assertEqual('rev1', base)
 
515
            self.assertEqual('verified', verified)
 
516
        self.assertEqual('rev2a', revision)
 
517
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
 
518
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
 
519
            tree_b.branch.base, patch_type=None,
 
520
            public_branch=tree_a.branch.base)
 
521
        base, revision, verified = md.get_merge_request(
 
522
            tree_b.branch.repository)
 
523
        if isinstance(md, merge_directive.MergeDirective):
 
524
            self.assertIs(None, base)
 
525
            self.assertEqual('inapplicable', verified)
 
526
        else:
 
527
            self.assertEqual('rev1', base)
 
528
            self.assertEqual('inapplicable', verified)
 
529
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
 
530
            tree_b.branch.base, patch_type='diff',
 
531
            public_branch=tree_a.branch.base)
 
532
        base, revision, verified = md.get_merge_request(
 
533
            tree_b.branch.repository)
 
534
        if isinstance(md, merge_directive.MergeDirective):
 
535
            self.assertIs(None, base)
 
536
            self.assertEqual('inapplicable', verified)
 
537
        else:
 
538
            self.assertEqual('rev1', base)
 
539
            self.assertEqual('verified', verified)
 
540
        md.patch='asdf'
 
541
        base, revision, verified = md.get_merge_request(
 
542
            tree_b.branch.repository)
 
543
        if isinstance(md, merge_directive.MergeDirective):
 
544
            self.assertIs(None, base)
 
545
            self.assertEqual('inapplicable', verified)
 
546
        else:
 
547
            self.assertEqual('rev1', base)
550
548
            self.assertEqual('failed', verified)
551
549
 
552
550
    def test_install_revisions_bundle(self):
553
551
        tree_a, tree_b, branch_c = self.make_trees()
554
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 36,
555
 
                               tree_b.branch.base, patch_type='bundle',
556
 
                               public_branch=tree_a.branch.base)
557
 
        self.assertFalse(tree_b.branch.repository.has_revision(b'rev2a'))
 
552
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
 
553
            tree_b.branch.base, patch_type='bundle',
 
554
            public_branch=tree_a.branch.base)
 
555
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
558
556
        revision = md.install_revisions(tree_b.branch.repository)
559
 
        self.assertEqual(b'rev2a', revision)
560
 
        self.assertTrue(tree_b.branch.repository.has_revision(b'rev2a'))
 
557
        self.assertEqual('rev2a', revision)
 
558
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
561
559
 
562
560
    def test_get_target_revision_nofetch(self):
563
561
        tree_a, tree_b, branch_c = self.make_trees()
564
562
        tree_b.branch.fetch(tree_a.branch)
565
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 36,
566
 
                               tree_b.branch.base, patch_type=None,
567
 
                               public_branch=tree_a.branch.base)
 
563
        md = self.from_objects( tree_a.branch.repository, 'rev2a', 500, 36,
 
564
            tree_b.branch.base, patch_type=None,
 
565
            public_branch=tree_a.branch.base)
568
566
        md.source_branch = '/dev/null'
569
567
        revision = md.install_revisions(tree_b.branch.repository)
570
 
        self.assertEqual(b'rev2a', revision)
 
568
        self.assertEqual('rev2a', revision)
571
569
 
572
570
    def test_use_submit_for_missing_dependency(self):
573
571
        tree_a, tree_b, branch_c = self.make_trees()
574
572
        branch_c.pull(tree_a.branch)
575
 
        self.build_tree_contents([('tree_a/file', b'content_q\ncontent_r\n')])
576
 
        tree_a.commit('rev3a', rev_id=b'rev3a')
577
 
        md = self.from_objects(tree_a.branch.repository, b'rev3a', 500, 36,
578
 
                               branch_c.base, base_revision_id=b'rev2a')
 
573
        self.build_tree_contents([('tree_a/file', 'content_q\ncontent_r\n')])
 
574
        tree_a.commit('rev3a', rev_id='rev3a')
 
575
        md = self.from_objects(tree_a.branch.repository, 'rev3a', 500, 36,
 
576
            branch_c.base, base_revision_id='rev2a')
579
577
        revision = md.install_revisions(tree_b.branch.repository)
580
578
 
581
579
    def test_handle_target_not_a_branch(self):
582
580
        tree_a, tree_b, branch_c = self.make_trees()
583
581
        branch_c.pull(tree_a.branch)
584
 
        self.build_tree_contents([('tree_a/file', b'content_q\ncontent_r\n')])
585
 
        tree_a.commit('rev3a', rev_id=b'rev3a')
586
 
        md = self.from_objects(tree_a.branch.repository, b'rev3a', 500, 36,
587
 
                               branch_c.base, base_revision_id=b'rev2a')
 
582
        self.build_tree_contents([('tree_a/file', 'content_q\ncontent_r\n')])
 
583
        tree_a.commit('rev3a', rev_id='rev3a')
 
584
        md = self.from_objects(tree_a.branch.repository, 'rev3a', 500, 36,
 
585
            branch_c.base, base_revision_id='rev2a')
588
586
        md.target_branch = self.get_url('not-a-branch')
589
587
        self.assertRaises(errors.TargetNotBranch, md.install_revisions,
590
 
                          tree_b.branch.repository)
 
588
                tree_b.branch.repository)
591
589
 
592
590
 
593
591
class TestMergeDirective1Branch(tests.TestCaseWithTransport,
594
 
                                TestMergeDirectiveBranch):
 
592
    TestMergeDirectiveBranch):
595
593
    """Test merge directive format 1 with a branch"""
596
594
 
597
595
    EMAIL1 = EMAIL1
599
597
    EMAIL2 = EMAIL2
600
598
 
601
599
    def from_objects(self, repository, revision_id, time, timezone,
602
 
                     target_branch, patch_type='bundle', local_target_branch=None,
603
 
                     public_branch=None, message=None, base_revision_id=None):
 
600
        target_branch, patch_type='bundle', local_target_branch=None,
 
601
        public_branch=None, message=None, base_revision_id=None):
604
602
        if base_revision_id is not None:
605
603
            raise tests.TestNotApplicable('This format does not support'
606
604
                                          ' explicit bases.')
607
 
        with repository.lock_write():
608
 
            return merge_directive.MergeDirective.from_objects(repository,
609
 
                                                               revision_id, time, timezone, target_branch, patch_type,
610
 
                                                               local_target_branch, public_branch, message)
 
605
        repository.lock_write()
 
606
        try:
 
607
            return merge_directive.MergeDirective.from_objects( repository,
 
608
                revision_id, time, timezone, target_branch, patch_type,
 
609
                local_target_branch, public_branch, message)
 
610
        finally:
 
611
            repository.unlock()
611
612
 
612
613
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
613
 
                             target_branch, patch=None, patch_type=None,
614
 
                             source_branch=None, message=None):
 
614
                 target_branch, patch=None, patch_type=None,
 
615
                 source_branch=None, message=None):
615
616
        return merge_directive.MergeDirective(revision_id, testament_sha1,
616
 
                                              time, timezone, target_branch, patch, patch_type,
617
 
                                              source_branch, message)
 
617
                 time, timezone, target_branch, patch, patch_type,
 
618
                 source_branch, message)
618
619
 
619
620
 
620
621
class TestMergeDirective2Branch(tests.TestCaseWithTransport,
621
 
                                TestMergeDirectiveBranch):
 
622
    TestMergeDirectiveBranch):
622
623
    """Test merge directive format 2 with a branch"""
623
624
 
624
625
    EMAIL1 = EMAIL1_2
626
627
    EMAIL2 = EMAIL2_2
627
628
 
628
629
    def from_objects(self, repository, revision_id, time, timezone,
629
 
                     target_branch, patch_type='bundle', local_target_branch=None,
630
 
                     public_branch=None, message=None, base_revision_id=None):
 
630
        target_branch, patch_type='bundle', local_target_branch=None,
 
631
        public_branch=None, message=None, base_revision_id=None):
631
632
        include_patch = (patch_type in ('bundle', 'diff'))
632
633
        include_bundle = (patch_type == 'bundle')
633
634
        self.assertTrue(patch_type in ('bundle', 'diff', None))
637
638
            message, base_revision_id)
638
639
 
639
640
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
640
 
                             target_branch, patch=None, patch_type=None,
641
 
                             source_branch=None, message=None, base_revision_id=b'null:'):
 
641
                 target_branch, patch=None, patch_type=None,
 
642
                 source_branch=None, message=None, base_revision_id='null:'):
642
643
        if patch_type == 'bundle':
643
644
            bundle = patch
644
645
            patch = None
645
646
        else:
646
647
            bundle = None
647
648
        return merge_directive.MergeDirective2(revision_id, testament_sha1,
648
 
                                               time, timezone, target_branch, patch, source_branch, message,
649
 
                                               bundle, base_revision_id)
 
649
            time, timezone, target_branch, patch, source_branch, message,
 
650
            bundle, base_revision_id)
650
651
 
651
652
    def test_base_revision(self):
652
653
        tree_a, tree_b, branch_c = self.make_trees()
653
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 60,
654
 
                               tree_b.branch.base, patch_type='bundle',
655
 
                               public_branch=tree_a.branch.base, base_revision_id=None)
656
 
        self.assertEqual(b'rev1', md.base_revision_id)
657
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 60,
658
 
                               tree_b.branch.base, patch_type='bundle',
659
 
                               public_branch=tree_a.branch.base, base_revision_id=b'null:')
660
 
        self.assertEqual(b'null:', md.base_revision_id)
 
654
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 60,
 
655
            tree_b.branch.base, patch_type='bundle',
 
656
            public_branch=tree_a.branch.base, base_revision_id=None)
 
657
        self.assertEqual('rev1', md.base_revision_id)
 
658
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 60,
 
659
            tree_b.branch.base, patch_type='bundle',
 
660
            public_branch=tree_a.branch.base, base_revision_id='null:')
 
661
        self.assertEqual('null:', md.base_revision_id)
661
662
        lines = md.to_lines()
662
663
        md2 = merge_directive.MergeDirective.from_lines(lines)
663
664
        self.assertEqual(md2.base_revision_id, md.base_revision_id)
664
665
 
665
666
    def test_patch_verification(self):
666
667
        tree_a, tree_b, branch_c = self.make_trees()
667
 
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 60,
668
 
                               tree_b.branch.base, patch_type='bundle',
669
 
                               public_branch=tree_a.branch.base)
 
668
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 60,
 
669
            tree_b.branch.base, patch_type='bundle',
 
670
            public_branch=tree_a.branch.base)
670
671
        lines = md.to_lines()
671
672
        md2 = merge_directive.MergeDirective.from_lines(lines)
672
673
        md2._verify_patch(tree_a.branch.repository)
673
674
        # Strip trailing whitespace
674
 
        md2.patch = md2.patch.replace(b' \n', b'\n')
 
675
        md2.patch = md2.patch.replace(' \n', '\n')
675
676
        md2._verify_patch(tree_a.branch.repository)
676
677
        # Convert to Mac line-endings
677
 
        md2.patch = re.sub(b'(\r\n|\r|\n)', b'\r', md2.patch)
 
678
        md2.patch = re.sub('(\r\n|\r|\n)', '\r', md2.patch)
678
679
        self.assertTrue(md2._verify_patch(tree_a.branch.repository))
679
680
        # Convert to DOS line-endings
680
 
        md2.patch = re.sub(b'(\r\n|\r|\n)', b'\r\n', md2.patch)
 
681
        md2.patch = re.sub('(\r\n|\r|\n)', '\r\n', md2.patch)
681
682
        self.assertTrue(md2._verify_patch(tree_a.branch.repository))
682
 
        md2.patch = md2.patch.replace(b'content_c', b'content_d')
 
683
        md2.patch = md2.patch.replace('content_c', 'content_d')
683
684
        self.assertFalse(md2._verify_patch(tree_a.branch.repository))
684
685
 
685
686
 
687
688
 
688
689
    def test_parse_old_merge_directive(self):
689
690
        md = merge_directive.MergeDirective.from_lines(INPUT1_2_OLD)
690
 
        self.assertEqual(b'example:', md.revision_id)
691
 
        self.assertEqual(b'sha', md.testament_sha1)
 
691
        self.assertEqual('example:', md.revision_id)
 
692
        self.assertEqual('sha', md.testament_sha1)
692
693
        self.assertEqual('http://example.com', md.target_branch)
693
694
        self.assertEqual('http://example.org', md.source_branch)
694
695
        self.assertEqual(453, md.time)
695
696
        self.assertEqual(120, md.timezone)
696
 
        self.assertEqual(b'booga', md.patch)
 
697
        self.assertEqual('booga', md.patch)
697
698
        self.assertEqual('diff', md.patch_type)
698
699
        self.assertEqual('Hi mom!', md.message)
699
700
 
733
734
        tree = self.make_branch_and_tree('foo')
734
735
        tree.commit('foo')
735
736
        directive = merge_directive.MergeDirective2(
736
 
            tree.branch.last_revision(), b'sha', 0, 0, b'sha',
 
737
            tree.branch.last_revision(), 'sha', 0, 0, 'sha',
737
738
            source_branch=tree.branch.base,
738
739
            base_revision_id=tree.branch.last_revision(),
739
740
            message='This code rox')
740
741
        directive.compose_merge_request(client, 'jrandom@example.com',
741
 
                                        None, tree.branch)
 
742
            None, tree.branch)
742
743
        return client, directive
743
744
 
744
745
    def test_no_supports_body(self):
745
746
        test_hook = TestHook('foo')
746
747
        old_warn = trace.warning
747
748
        warnings = []
748
 
 
749
749
        def warn(*args):
750
750
            warnings.append(args)
751
751
        trace.warning = warn
752
752
        try:
753
753
            client, directive = self.compose_with_hooks([test_hook],
754
 
                                                        supports_body=False)
 
754
                supports_body=False)
755
755
        finally:
756
756
            trace.warning = old_warn
757
757
        self.assertEqual(0, len(test_hook.calls))