1
# Copyright (C) 2007 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29
OUTPUT1 = b"""# Bazaar merge directive format 1
30
# revision_id: example:
31
# target_branch: http://example.com
33
# timestamp: 1970-01-01 00:09:33 +0002
37
OUTPUT1_2 = b"""# Bazaar merge directive format 2 (Bazaar 0.90)
38
# revision_id: example:
39
# target_branch: http://example.com
41
# timestamp: 1970-01-01 00:09:33 +0002
42
# base_revision_id: null:
47
OUTPUT2 = b"""# Bazaar merge directive format 1
48
# revision_id: example:
49
# target_branch: http://example.com
51
# timestamp: 1970-01-01 00:09:33 +0002
52
# source_branch: http://example.org
57
OUTPUT2_2 = b"""# Bazaar merge directive format 2 (Bazaar 0.90)
58
# revision_id: example:
59
# target_branch: http://example.com
61
# timestamp: 1970-01-01 00:09:33 +0002
62
# source_branch: http://example.org
64
# base_revision_id: null:
70
I was thinking today about creating a merge directive.
76
(I've pasted it in the body of this message)
80
# Bazaar merge directive format 1\r
81
# revision_id: example:
82
# target_branch: http://example.com
84
# timestamp: 1970-01-01 00:09:33 +0002
85
# source_branch: http://example.org
88
booga""".splitlines(True)
92
I was thinking today about creating a merge directive.
98
(I've pasted it in the body of this message)
102
# Bazaar merge directive format 2 (Bazaar 0.90)\r
103
# revision_id: example:
104
# target_branch: http://example.com
105
# testament_sha1: sha
106
# timestamp: 1970-01-01 00:09:33 +0002
107
# source_branch: http://example.org
108
# base_revision_id: null:
112
booga""".splitlines(True)
116
I was thinking today about creating a merge directive.
122
(I've pasted it in the body of this message)
126
# Bazaar merge directive format 2 (Bazaar 0.19)\r
127
# revision_id: example:
128
# target_branch: http://example.com
129
# testament_sha1: sha
130
# timestamp: 1970-01-01 00:09:33 +0002
131
# source_branch: http://example.org
132
# base_revision_id: null:
136
booga""".splitlines(True)
139
OLD_DIRECTIVE_2 = b"""# Bazaar merge directive format 2 (Bazaar 0.19)
140
# revision_id: abentley@panoramicfeedback.com-20070807234458-\
142
# target_branch: http://panoramicfeedback.com/opensource/bzr/repo\
144
# testament_sha1: d825a5cdb267a90ec2ba86b00895f3d8a9bed6bf
145
# timestamp: 2007-08-10 16:15:02 -0400
146
# source_branch: http://panoramicfeedback.com/opensource/bzr/repo\
148
# base_revision_id: abentley@panoramicfeedback.com-20070731163346-\
154
class TestMergeDirective(object):
156
def test_merge_source(self):
159
self.assertRaises(errors.NoMergeSource, self.make_merge_directive,
160
b'example:', b'sha', time, timezone, 'http://example.com')
161
self.assertRaises(errors.NoMergeSource, self.make_merge_directive,
162
b'example:', b'sha', time, timezone, 'http://example.com',
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')
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',
172
self.assertEqual('bar', md2.source_branch)
174
def test_serialization(self):
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()))
185
def test_deserialize_junk(self):
187
self.assertRaises(errors.NotAMergeDirective,
188
merge_directive.MergeDirective.from_lines, [b'lala'])
190
def test_deserialize_empty(self):
191
self.assertRaises(errors.NotAMergeDirective,
192
merge_directive.MergeDirective.from_lines, [])
194
def test_deserialize_leading_junk(self):
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)
198
self.assertEqual('http://example.com', md.target_branch)
199
self.assertEqual('http://example.org', md.source_branch)
200
self.assertEqual(453, md.time)
201
self.assertEqual(120, md.timezone)
202
self.assertEqual(b'booga', md.patch)
203
self.assertEqual('diff', md.patch_type)
204
self.assertEqual('Hi mom!', md.message)
206
def test_roundtrip(self):
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')
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)
216
self.assertEqual('http://example.com', md2.target_branch)
217
self.assertEqual('http://example.org', md2.source_branch)
218
self.assertEqual(time, md2.time)
219
self.assertEqual(timezone, md2.timezone)
220
self.assertEqual('diff', md2.patch_type)
221
self.assertEqual(b'booga', md2.patch)
222
self.assertEqual(None, md2.message)
223
self.set_bundle(md, b"# Bazaar revision bundle v0.9\n#\n")
224
md.message = "Hi mom!"
225
lines = md.to_lines()
226
md3 = merge_directive.MergeDirective.from_lines(lines)
227
self.assertEqual(b"# Bazaar revision bundle v0.9\n#\n", md3.bundle)
228
self.assertEqual("bundle", md3.patch_type)
229
self.assertContainsRe(md3.to_lines()[0],
230
b'^# Bazaar merge directive format ')
231
self.assertEqual("Hi mom!", md3.message)
233
self.assertIs(None, md3.get_raw_bundle())
234
md4 = merge_directive.MergeDirective.from_lines(md3.to_lines())
235
self.assertIs(None, md4.patch_type)
238
class TestMergeDirective1(tests.TestCase, TestMergeDirective):
239
"""Test merge directive format 1"""
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):
250
return merge_directive.MergeDirective(revision_id, testament_sha1,
251
time, timezone, target_branch, patch, patch_type,
252
source_branch, message)
255
def set_bundle(md, value):
258
def test_require_patch(self):
261
self.assertRaises(errors.PatchMissing, merge_directive.MergeDirective,
262
b'example:', b'sha', time, timezone, 'http://example.com',
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'')
270
class TestMergeDirective2(tests.TestCase, TestMergeDirective):
271
"""Test merge directive format 2"""
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:'):
282
if patch_type == 'bundle':
287
return merge_directive.MergeDirective2(revision_id, testament_sha1,
288
time, timezone, target_branch, patch, source_branch, message,
289
bundle, base_revision_id)
292
def set_bundle(md, value):
296
EMAIL1 = """From: "J. Random Hacker" <jrandom@example.com>
297
Subject: Commit of rev2a
299
User-Agent: Bazaar \\(.*\\)
301
# Bazaar merge directive format 1
303
# target_branch: (.|\n)*
305
# timestamp: 1970-01-01 00:08:56 \\+0001
306
# source_branch: (.|\n)*
310
EMAIL1_2 = """From: "J. Random Hacker" <jrandom@example.com>
311
Subject: Commit of rev2a
313
User-Agent: Bazaar \\(.*\\)
315
# Bazaar merge directive format 2 \\(Bazaar 0.90\\)
317
# target_branch: (.|\n)*
319
# timestamp: 1970-01-01 00:08:56 \\+0001
320
# source_branch: (.|\n)*
324
EMAIL2 = """From: "J. Random Hacker" <jrandom@example.com>
325
Subject: Commit of rev2a with special message
327
User-Agent: Bazaar \\(.*\\)
329
# Bazaar merge directive format 1
331
# target_branch: (.|\n)*
333
# timestamp: 1970-01-01 00:08:56 \\+0001
334
# source_branch: (.|\n)*
335
# message: Commit of rev2a with special message
338
EMAIL2_2 = """From: "J. Random Hacker" <jrandom@example.com>
339
Subject: Commit of rev2a with special message
341
User-Agent: Bazaar \\(.*\\)
343
# Bazaar merge directive format 2 \\(Bazaar 0.90\\)
345
# target_branch: (.|\n)*
347
# timestamp: 1970-01-01 00:08:56 \\+0001
348
# source_branch: (.|\n)*
349
# message: Commit of rev2a with special message
353
class TestMergeDirectiveBranch(object):
355
def make_trees(self):
356
tree_a = self.make_branch_and_tree('tree_a')
357
tree_a.branch.get_config_stack().set(
358
'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')])
361
tree_a.add(['file', 'file_2'])
362
tree_a.commit('message', rev_id=b'rev1')
363
tree_b = tree_a.controldir.sprout('tree_b').open_workingtree()
364
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')
369
return tree_a, tree_b, branch_c
371
def test_empty_target(self):
372
tree_a, tree_b, branch_c = self.make_trees()
373
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)
378
def test_disk_name(self):
379
tree_a, tree_b, branch_c = self.make_trees()
380
tree_a.branch.nick = 'fancy <name>'
381
md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 120,
383
self.assertEqual('fancy-name-2', md.get_disk_name(tree_a.branch))
385
def test_disk_name_old_revno(self):
386
tree_a, tree_b, branch_c = self.make_trees()
387
tree_a.branch.nick = 'fancy-name'
388
md = self.from_objects(tree_a.branch.repository, b'rev1', 500, 120,
390
self.assertEqual('fancy-name-1', md.get_disk_name(tree_a.branch))
392
def test_generate_patch(self):
393
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')
402
def test_public_branch(self):
403
tree_a, tree_b, branch_c = self.make_trees()
404
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')
407
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)
410
# 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)
413
# public branch is provided with a bundle, despite possibly being out
414
# of date, because it's not required if a bundle is present.
415
self.assertEqual(md1.source_branch, branch_c.base)
416
# Once we update the public branch, we can generate a diff.
417
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)
421
def test_use_public_submit_branch(self):
422
tree_a, tree_b, branch_c = self.make_trees()
423
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)
426
self.assertEqual(md.target_branch, tree_b.branch.base)
427
tree_b.branch.set_public_branch('http://example.com')
428
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)
431
self.assertEqual(md2.target_branch, 'http://example.com')
433
def test_message(self):
434
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')
439
self.assertIs(None, md3.patch)
440
self.assertEqual('Merge message', md3.message)
442
def test_generate_bundle(self):
443
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)
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')
453
def test_broken_bundle(self):
454
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)
457
lines = md1.to_lines()
458
lines = [l.replace(b'\n', b'\r\n') for l in lines]
459
md2 = merge_directive.MergeDirective.from_lines(lines)
460
self.assertEqual(b'rev2a', md2.revision_id)
462
def test_signing(self):
466
class FakeBranch(object):
467
def get_config_stack(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')
472
old_strategy = gpg.GPGStrategy
473
gpg.GPGStrategy = gpg.LoopbackGPGStrategy
475
signed = md.to_signed(FakeBranch())
477
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')
482
def test_email(self):
483
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)
487
message = md.to_email('pqm@example.com', tree_a.branch)
488
self.assertContainsRe(message.as_string(), self.EMAIL1)
489
md.message = 'Commit of rev2a with special message'
490
message = md.to_email('pqm@example.com', tree_a.branch)
491
self.assertContainsRe(message.as_string(), self.EMAIL2)
493
def test_install_revisions_branch(self):
494
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'))
499
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'))
503
def test_get_merge_request(self):
504
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'))
509
md.install_revisions(tree_b.branch.repository)
510
base, revision, verified = md.get_merge_request(
511
tree_b.branch.repository)
512
if isinstance(md, merge_directive.MergeDirective):
513
self.assertIs(None, base)
514
self.assertEqual('inapplicable', verified)
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)
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)
540
self.assertEqual(b'rev1', base)
541
self.assertEqual('verified', verified)
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)
549
self.assertEqual(b'rev1', base)
550
self.assertEqual('failed', verified)
552
def test_install_revisions_bundle(self):
553
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'))
558
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'))
562
def test_get_target_revision_nofetch(self):
563
tree_a, tree_b, branch_c = self.make_trees()
564
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)
568
md.source_branch = '/dev/null'
569
revision = md.install_revisions(tree_b.branch.repository)
570
self.assertEqual(b'rev2a', revision)
572
def test_use_submit_for_missing_dependency(self):
573
tree_a, tree_b, branch_c = self.make_trees()
574
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')
579
revision = md.install_revisions(tree_b.branch.repository)
581
def test_handle_target_not_a_branch(self):
582
tree_a, tree_b, branch_c = self.make_trees()
583
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')
588
md.target_branch = self.get_url('not-a-branch')
589
self.assertRaises(errors.TargetNotBranch, md.install_revisions,
590
tree_b.branch.repository)
593
class TestMergeDirective1Branch(tests.TestCaseWithTransport,
594
TestMergeDirectiveBranch):
595
"""Test merge directive format 1 with a branch"""
601
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):
604
if base_revision_id is not None:
605
raise tests.TestNotApplicable('This format does not support'
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)
612
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):
615
return merge_directive.MergeDirective(revision_id, testament_sha1,
616
time, timezone, target_branch, patch, patch_type,
617
source_branch, message)
620
class TestMergeDirective2Branch(tests.TestCaseWithTransport,
621
TestMergeDirectiveBranch):
622
"""Test merge directive format 2 with a branch"""
628
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):
631
include_patch = (patch_type in ('bundle', 'diff'))
632
include_bundle = (patch_type == 'bundle')
633
self.assertTrue(patch_type in ('bundle', 'diff', None))
634
return merge_directive.MergeDirective2.from_objects(
635
repository, revision_id, time, timezone, target_branch,
636
include_patch, include_bundle, local_target_branch, public_branch,
637
message, base_revision_id)
639
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:'):
642
if patch_type == 'bundle':
647
return merge_directive.MergeDirective2(revision_id, testament_sha1,
648
time, timezone, target_branch, patch, source_branch, message,
649
bundle, base_revision_id)
651
def test_base_revision(self):
652
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)
661
lines = md.to_lines()
662
md2 = merge_directive.MergeDirective.from_lines(lines)
663
self.assertEqual(md2.base_revision_id, md.base_revision_id)
665
def test_patch_verification(self):
666
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)
670
lines = md.to_lines()
671
md2 = merge_directive.MergeDirective.from_lines(lines)
672
md2._verify_patch(tree_a.branch.repository)
673
# Strip trailing whitespace
674
md2.patch = md2.patch.replace(b' \n', b'\n')
675
md2._verify_patch(tree_a.branch.repository)
676
# Convert to Mac line-endings
677
md2.patch = re.sub(b'(\r\n|\r|\n)', b'\r', md2.patch)
678
self.assertTrue(md2._verify_patch(tree_a.branch.repository))
679
# Convert to DOS line-endings
680
md2.patch = re.sub(b'(\r\n|\r|\n)', b'\r\n', md2.patch)
681
self.assertTrue(md2._verify_patch(tree_a.branch.repository))
682
md2.patch = md2.patch.replace(b'content_c', b'content_d')
683
self.assertFalse(md2._verify_patch(tree_a.branch.repository))
686
class TestParseOldMergeDirective2(tests.TestCase):
688
def test_parse_old_merge_directive(self):
689
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)
692
self.assertEqual('http://example.com', md.target_branch)
693
self.assertEqual('http://example.org', md.source_branch)
694
self.assertEqual(453, md.time)
695
self.assertEqual(120, md.timezone)
696
self.assertEqual(b'booga', md.patch)
697
self.assertEqual('diff', md.patch_type)
698
self.assertEqual('Hi mom!', md.message)
701
class TestHook(object):
702
"""Hook callback for test purposes."""
704
def __init__(self, result=None):
708
def __call__(self, params):
709
self.calls.append(params)
713
class HookMailClient(mail_client.MailClient):
714
"""Mail client for testing hooks."""
716
def __init__(self, config):
720
def compose(self, prompt, to, subject, attachment, mime_subtype,
721
extension, basename=None, body=None):
725
class TestBodyHook(tests.TestCaseWithTransport):
727
def compose_with_hooks(self, test_hooks, supports_body=True):
728
client = HookMailClient({})
729
client.supports_body = supports_body
730
for test_hook in test_hooks:
731
merge_directive.MergeDirective.hooks.install_named_hook(
732
'merge_request_body', test_hook, 'test')
733
tree = self.make_branch_and_tree('foo')
735
directive = merge_directive.MergeDirective2(
736
tree.branch.last_revision(), b'sha', 0, 0, b'sha',
737
source_branch=tree.branch.base,
738
base_revision_id=tree.branch.last_revision(),
739
message='This code rox')
740
directive.compose_merge_request(client, 'jrandom@example.com',
742
return client, directive
744
def test_no_supports_body(self):
745
test_hook = TestHook('foo')
746
old_warn = trace.warning
750
warnings.append(args)
753
client, directive = self.compose_with_hooks([test_hook],
756
trace.warning = old_warn
757
self.assertEqual(0, len(test_hook.calls))
758
self.assertEqual(('Cannot run merge_request_body hooks because mail'
759
' client %s does not support message bodies.',
760
'HookMailClient'), warnings[0])
762
def test_body_hook(self):
763
test_hook = TestHook('foo')
764
client, directive = self.compose_with_hooks([test_hook])
765
self.assertEqual(1, len(test_hook.calls))
766
self.assertEqual('foo', client.body)
767
params = test_hook.calls[0]
768
self.assertIsInstance(params,
769
merge_directive.MergeRequestBodyParams)
770
self.assertIs(None, params.body)
771
self.assertIs(None, params.orig_body)
772
self.assertEqual('jrandom@example.com', params.to)
773
self.assertEqual('[MERGE] This code rox', params.subject)
774
self.assertEqual(directive, params.directive)
775
self.assertEqual('foo-1', params.basename)
777
def test_body_hook_chaining(self):
778
test_hook1 = TestHook('foo')
779
test_hook2 = TestHook('bar')
780
client = self.compose_with_hooks([test_hook1, test_hook2])[0]
781
self.assertEqual(None, test_hook1.calls[0].body)
782
self.assertEqual(None, test_hook1.calls[0].orig_body)
783
self.assertEqual('foo', test_hook2.calls[0].body)
784
self.assertEqual(None, test_hook2.calls[0].orig_body)
785
self.assertEqual('bar', client.body)
added
removed
breezy/tests/test_merge_directive.py
