/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: 2019-03-04 00:16:27 UTC
  • mfrom: (7293 work)
  • mto: This revision was merged to the branch mainline in revision 7318.
  • Revision ID: jelmer@jelmer.uk-20190304001627-v6u7o6pf97tukhek
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_merge_directive.py
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
                          b'example:', b'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')
 
162
                          b'example:', b'sha', time, timezone, 'http://example.com',
 
163
                          patch_type='diff')
164
164
        self.make_merge_directive(b'example:', b'sha', time, timezone,
165
 
            'http://example.com', source_branch='http://example.org')
 
165
                                  'http://example.com', source_branch='http://example.org')
166
166
        md = self.make_merge_directive(b'null:', b'sha', time, timezone,
167
 
            'http://example.com', patch=b'blah', patch_type='bundle')
 
167
                                       'http://example.com', patch=b'blah', patch_type='bundle')
168
168
        self.assertIs(None, md.source_branch)
169
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')
 
170
                                        'http://example.com', patch=b'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
177
        md = self.make_merge_directive(b'example:', b'sha', time, timezone,
178
 
            'http://example.com', patch=b'booga', patch_type='bundle')
 
178
                                       'http://example.com', patch=b'booga', patch_type='bundle')
179
179
        self.assertEqualDiff(self.OUTPUT1, b''.join(md.to_lines()))
180
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!")
 
181
                                       'http://example.com', source_branch="http://example.org",
 
182
                                       patch=b'booga', patch_type='diff', message="Hi mom!")
183
183
        self.assertEqualDiff(self.OUTPUT2, b''.join(md.to_lines()))
184
184
 
185
185
    def test_deserialize_junk(self):
207
207
        time = 500000
208
208
        timezone = 7.5 * 3600
209
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')
 
210
                                       'http://example.com', source_branch="http://example.org",
 
211
                                       patch=b'booga', patch_type='diff')
212
212
        md2 = merge_directive.MergeDirective.from_lines(md.to_lines())
213
213
        self.assertEqual(b'example:', md2.revision_id)
214
214
        self.assertIsInstance(md2.revision_id, bytes)
227
227
        self.assertEqual(b"# 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
                              b'^# 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')
 
262
                          b'example:', b'sha', time, timezone, 'http://example.com',
 
263
                          patch_type='bundle')
264
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')
 
265
                                            'http://example.com', source_branch="http://example.org",
 
266
                                            patch=b'', patch_type='diff')
267
267
        self.assertEqual(md.patch, b'')
268
268
 
269
269
 
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=b'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):
349
349
# message: Commit of rev2a with special message
350
350
"""
351
351
 
 
352
 
352
353
class TestMergeDirectiveBranch(object):
353
354
 
354
355
    def make_trees(self):
371
372
        tree_a, tree_b, branch_c = self.make_trees()
372
373
        tree_d = self.make_branch_and_tree('tree_d')
373
374
        md2 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 120,
374
 
            tree_d.branch.base, patch_type='diff',
375
 
            public_branch=tree_a.branch.base)
 
375
                                tree_d.branch.base, patch_type='diff',
 
376
                                public_branch=tree_a.branch.base)
376
377
 
377
378
    def test_disk_name(self):
378
379
        tree_a, tree_b, branch_c = self.make_trees()
379
380
        tree_a.branch.nick = 'fancy <name>'
380
381
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 120,
381
 
            tree_b.branch.base)
 
382
                               tree_b.branch.base)
382
383
        self.assertEqual('fancy-name-2', md.get_disk_name(tree_a.branch))
383
384
 
384
385
    def test_disk_name_old_revno(self):
385
386
        tree_a, tree_b, branch_c = self.make_trees()
386
387
        tree_a.branch.nick = 'fancy-name'
387
388
        md = self.from_objects(tree_a.branch.repository, b'rev1', 500, 120,
388
 
            tree_b.branch.base)
 
389
                               tree_b.branch.base)
389
390
        self.assertEqual('fancy-name-1', md.get_disk_name(tree_a.branch))
390
391
 
391
392
    def test_generate_patch(self):
392
393
        tree_a, tree_b, branch_c = self.make_trees()
393
394
        md2 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 120,
394
 
            tree_b.branch.base, patch_type='diff',
395
 
            public_branch=tree_a.branch.base)
 
395
                                tree_b.branch.base, patch_type='diff',
 
396
                                public_branch=tree_a.branch.base)
396
397
        self.assertNotContainsRe(md2.patch, b'Bazaar revision bundle')
397
398
        self.assertContainsRe(md2.patch, b'\\+content_c')
398
399
        self.assertNotContainsRe(md2.patch, b'\\+\\+\\+ b/')
401
402
    def test_public_branch(self):
402
403
        tree_a, tree_b, branch_c = self.make_trees()
403
404
        self.assertRaises(errors.PublicBranchOutOfDate,
404
 
            self.from_objects, tree_a.branch.repository, b'rev2a', 500, 144,
405
 
            tree_b.branch.base, public_branch=branch_c.base, patch_type='diff')
 
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')
406
407
        self.assertRaises(errors.PublicBranchOutOfDate,
407
 
            self.from_objects, tree_a.branch.repository, b'rev2a', 500, 144,
408
 
            tree_b.branch.base, public_branch=branch_c.base, patch_type=None)
 
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)
409
410
        # public branch is not checked if patch format is bundle.
410
411
        md1 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 144,
411
 
            tree_b.branch.base, public_branch=branch_c.base)
 
412
                                tree_b.branch.base, public_branch=branch_c.base)
412
413
        # public branch is provided with a bundle, despite possibly being out
413
414
        # of date, because it's not required if a bundle is present.
414
415
        self.assertEqual(md1.source_branch, branch_c.base)
415
416
        # Once we update the public branch, we can generate a diff.
416
417
        branch_c.pull(tree_a.branch)
417
418
        md3 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 144,
418
 
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
 
419
                                tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
419
420
 
420
421
    def test_use_public_submit_branch(self):
421
422
        tree_a, tree_b, branch_c = self.make_trees()
422
423
        branch_c.pull(tree_a.branch)
423
424
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 144,
424
 
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
 
425
                               tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
425
426
        self.assertEqual(md.target_branch, tree_b.branch.base)
426
427
        tree_b.branch.set_public_branch('http://example.com')
427
428
        md2 = self.from_objects(
428
 
              tree_a.branch.repository, b'rev2a', 500, 144, tree_b.branch.base,
429
 
              patch_type=None, public_branch=branch_c.base)
 
429
            tree_a.branch.repository, b'rev2a', 500, 144, tree_b.branch.base,
 
430
            patch_type=None, public_branch=branch_c.base)
430
431
        self.assertEqual(md2.target_branch, 'http://example.com')
431
432
 
432
433
    def test_message(self):
433
434
        tree_a, tree_b, branch_c = self.make_trees()
434
435
        md3 = self.from_objects(tree_a.branch.repository, b'rev1', 500, 120,
435
 
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base,
436
 
            message='Merge message')
 
436
                                tree_b.branch.base, patch_type=None, public_branch=branch_c.base,
 
437
                                message='Merge message')
437
438
        md3.to_lines()
438
439
        self.assertIs(None, md3.patch)
439
440
        self.assertEqual('Merge message', md3.message)
441
442
    def test_generate_bundle(self):
442
443
        tree_a, tree_b, branch_c = self.make_trees()
443
444
        md1 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 120,
444
 
            tree_b.branch.base, public_branch=branch_c.base)
 
445
                                tree_b.branch.base, public_branch=branch_c.base)
445
446
 
446
447
        self.assertContainsRe(md1.get_raw_bundle(), b'Bazaar revision bundle')
447
448
        self.assertContainsRe(md1.patch, b'\\+content_c')
452
453
    def test_broken_bundle(self):
453
454
        tree_a, tree_b, branch_c = self.make_trees()
454
455
        md1 = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 120,
455
 
            tree_b.branch.base, public_branch=branch_c.base)
 
456
                                tree_b.branch.base, public_branch=branch_c.base)
456
457
        lines = md1.to_lines()
457
458
        lines = [l.replace(b'\n', b'\r\n') for l in lines]
458
459
        md2 = merge_directive.MergeDirective.from_lines(lines)
461
462
    def test_signing(self):
462
463
        time = 453
463
464
        timezone = 7200
 
465
 
464
466
        class FakeBranch(object):
465
467
            def get_config_stack(self):
466
468
                return self
467
469
        md = self.make_merge_directive(b'example:', b'sha', time, timezone,
468
 
            'http://example.com', source_branch="http://example.org",
469
 
            patch=b'booga', patch_type='diff')
 
470
                                       'http://example.com', source_branch="http://example.org",
 
471
                                       patch=b'booga', patch_type='diff')
470
472
        old_strategy = gpg.GPGStrategy
471
473
        gpg.GPGStrategy = gpg.LoopbackGPGStrategy
472
474
        try:
480
482
    def test_email(self):
481
483
        tree_a, tree_b, branch_c = self.make_trees()
482
484
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 476, 60,
483
 
            tree_b.branch.base, patch_type=None,
484
 
            public_branch=tree_a.branch.base)
 
485
                               tree_b.branch.base, patch_type=None,
 
486
                               public_branch=tree_a.branch.base)
485
487
        message = md.to_email('pqm@example.com', tree_a.branch)
486
488
        self.assertContainsRe(message.as_string(), self.EMAIL1)
487
489
        md.message = 'Commit of rev2a with special message'
491
493
    def test_install_revisions_branch(self):
492
494
        tree_a, tree_b, branch_c = self.make_trees()
493
495
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 36,
494
 
            tree_b.branch.base, patch_type=None,
495
 
            public_branch=tree_a.branch.base)
 
496
                               tree_b.branch.base, patch_type=None,
 
497
                               public_branch=tree_a.branch.base)
496
498
        self.assertFalse(tree_b.branch.repository.has_revision(b'rev2a'))
497
499
        revision = md.install_revisions(tree_b.branch.repository)
498
500
        self.assertEqual(b'rev2a', revision)
501
503
    def test_get_merge_request(self):
502
504
        tree_a, tree_b, branch_c = self.make_trees()
503
505
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 36,
504
 
            tree_b.branch.base, patch_type='bundle',
505
 
            public_branch=tree_a.branch.base)
 
506
                               tree_b.branch.base, patch_type='bundle',
 
507
                               public_branch=tree_a.branch.base)
506
508
        self.assertFalse(tree_b.branch.repository.has_revision(b'rev2a'))
507
509
        md.install_revisions(tree_b.branch.repository)
508
510
        base, revision, verified = md.get_merge_request(
516
518
        self.assertEqual(b'rev2a', revision)
517
519
        self.assertTrue(tree_b.branch.repository.has_revision(b'rev2a'))
518
520
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 36,
519
 
            tree_b.branch.base, patch_type=None,
520
 
            public_branch=tree_a.branch.base)
 
521
                               tree_b.branch.base, patch_type=None,
 
522
                               public_branch=tree_a.branch.base)
521
523
        base, revision, verified = md.get_merge_request(
522
524
            tree_b.branch.repository)
523
525
        if isinstance(md, merge_directive.MergeDirective):
527
529
            self.assertEqual(b'rev1', base)
528
530
            self.assertEqual('inapplicable', verified)
529
531
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 36,
530
 
            tree_b.branch.base, patch_type='diff',
531
 
            public_branch=tree_a.branch.base)
 
532
                               tree_b.branch.base, patch_type='diff',
 
533
                               public_branch=tree_a.branch.base)
532
534
        base, revision, verified = md.get_merge_request(
533
535
            tree_b.branch.repository)
534
536
        if isinstance(md, merge_directive.MergeDirective):
537
539
        else:
538
540
            self.assertEqual(b'rev1', base)
539
541
            self.assertEqual('verified', verified)
540
 
        md.patch=b'asdf'
 
542
        md.patch = b'asdf'
541
543
        base, revision, verified = md.get_merge_request(
542
544
            tree_b.branch.repository)
543
545
        if isinstance(md, merge_directive.MergeDirective):
550
552
    def test_install_revisions_bundle(self):
551
553
        tree_a, tree_b, branch_c = self.make_trees()
552
554
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 36,
553
 
            tree_b.branch.base, patch_type='bundle',
554
 
            public_branch=tree_a.branch.base)
 
555
                               tree_b.branch.base, patch_type='bundle',
 
556
                               public_branch=tree_a.branch.base)
555
557
        self.assertFalse(tree_b.branch.repository.has_revision(b'rev2a'))
556
558
        revision = md.install_revisions(tree_b.branch.repository)
557
559
        self.assertEqual(b'rev2a', revision)
560
562
    def test_get_target_revision_nofetch(self):
561
563
        tree_a, tree_b, branch_c = self.make_trees()
562
564
        tree_b.branch.fetch(tree_a.branch)
563
 
        md = self.from_objects( tree_a.branch.repository, b'rev2a', 500, 36,
564
 
            tree_b.branch.base, patch_type=None,
565
 
            public_branch=tree_a.branch.base)
 
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)
566
568
        md.source_branch = '/dev/null'
567
569
        revision = md.install_revisions(tree_b.branch.repository)
568
570
        self.assertEqual(b'rev2a', revision)
573
575
        self.build_tree_contents([('tree_a/file', b'content_q\ncontent_r\n')])
574
576
        tree_a.commit('rev3a', rev_id=b'rev3a')
575
577
        md = self.from_objects(tree_a.branch.repository, b'rev3a', 500, 36,
576
 
            branch_c.base, base_revision_id=b'rev2a')
 
578
                               branch_c.base, base_revision_id=b'rev2a')
577
579
        revision = md.install_revisions(tree_b.branch.repository)
578
580
 
579
581
    def test_handle_target_not_a_branch(self):
582
584
        self.build_tree_contents([('tree_a/file', b'content_q\ncontent_r\n')])
583
585
        tree_a.commit('rev3a', rev_id=b'rev3a')
584
586
        md = self.from_objects(tree_a.branch.repository, b'rev3a', 500, 36,
585
 
            branch_c.base, base_revision_id=b'rev2a')
 
587
                               branch_c.base, base_revision_id=b'rev2a')
586
588
        md.target_branch = self.get_url('not-a-branch')
587
589
        self.assertRaises(errors.TargetNotBranch, md.install_revisions,
588
 
                tree_b.branch.repository)
 
590
                          tree_b.branch.repository)
589
591
 
590
592
 
591
593
class TestMergeDirective1Branch(tests.TestCaseWithTransport,
592
 
    TestMergeDirectiveBranch):
 
594
                                TestMergeDirectiveBranch):
593
595
    """Test merge directive format 1 with a branch"""
594
596
 
595
597
    EMAIL1 = EMAIL1
597
599
    EMAIL2 = EMAIL2
598
600
 
599
601
    def from_objects(self, repository, revision_id, time, timezone,
600
 
        target_branch, patch_type='bundle', local_target_branch=None,
601
 
        public_branch=None, message=None, base_revision_id=None):
 
602
                     target_branch, patch_type='bundle', local_target_branch=None,
 
603
                     public_branch=None, message=None, base_revision_id=None):
602
604
        if base_revision_id is not None:
603
605
            raise tests.TestNotApplicable('This format does not support'
604
606
                                          ' explicit bases.')
605
607
        with repository.lock_write():
606
608
            return merge_directive.MergeDirective.from_objects(repository,
607
 
                revision_id, time, timezone, target_branch, patch_type,
608
 
                local_target_branch, public_branch, message)
 
609
                                                               revision_id, time, timezone, target_branch, patch_type,
 
610
                                                               local_target_branch, public_branch, message)
609
611
 
610
612
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
611
 
                 target_branch, patch=None, patch_type=None,
612
 
                 source_branch=None, message=None):
 
613
                             target_branch, patch=None, patch_type=None,
 
614
                             source_branch=None, message=None):
613
615
        return merge_directive.MergeDirective(revision_id, testament_sha1,
614
 
                 time, timezone, target_branch, patch, patch_type,
615
 
                 source_branch, message)
 
616
                                              time, timezone, target_branch, patch, patch_type,
 
617
                                              source_branch, message)
616
618
 
617
619
 
618
620
class TestMergeDirective2Branch(tests.TestCaseWithTransport,
619
 
    TestMergeDirectiveBranch):
 
621
                                TestMergeDirectiveBranch):
620
622
    """Test merge directive format 2 with a branch"""
621
623
 
622
624
    EMAIL1 = EMAIL1_2
624
626
    EMAIL2 = EMAIL2_2
625
627
 
626
628
    def from_objects(self, repository, revision_id, time, timezone,
627
 
        target_branch, patch_type='bundle', local_target_branch=None,
628
 
        public_branch=None, message=None, base_revision_id=None):
 
629
                     target_branch, patch_type='bundle', local_target_branch=None,
 
630
                     public_branch=None, message=None, base_revision_id=None):
629
631
        include_patch = (patch_type in ('bundle', 'diff'))
630
632
        include_bundle = (patch_type == 'bundle')
631
633
        self.assertTrue(patch_type in ('bundle', 'diff', None))
635
637
            message, base_revision_id)
636
638
 
637
639
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
638
 
                 target_branch, patch=None, patch_type=None,
639
 
                 source_branch=None, message=None, base_revision_id=b'null:'):
 
640
                             target_branch, patch=None, patch_type=None,
 
641
                             source_branch=None, message=None, base_revision_id=b'null:'):
640
642
        if patch_type == 'bundle':
641
643
            bundle = patch
642
644
            patch = None
643
645
        else:
644
646
            bundle = None
645
647
        return merge_directive.MergeDirective2(revision_id, testament_sha1,
646
 
            time, timezone, target_branch, patch, source_branch, message,
647
 
            bundle, base_revision_id)
 
648
                                               time, timezone, target_branch, patch, source_branch, message,
 
649
                                               bundle, base_revision_id)
648
650
 
649
651
    def test_base_revision(self):
650
652
        tree_a, tree_b, branch_c = self.make_trees()
651
653
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 60,
652
 
            tree_b.branch.base, patch_type='bundle',
653
 
            public_branch=tree_a.branch.base, base_revision_id=None)
 
654
                               tree_b.branch.base, patch_type='bundle',
 
655
                               public_branch=tree_a.branch.base, base_revision_id=None)
654
656
        self.assertEqual(b'rev1', md.base_revision_id)
655
657
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 60,
656
 
            tree_b.branch.base, patch_type='bundle',
657
 
            public_branch=tree_a.branch.base, base_revision_id=b'null:')
 
658
                               tree_b.branch.base, patch_type='bundle',
 
659
                               public_branch=tree_a.branch.base, base_revision_id=b'null:')
658
660
        self.assertEqual(b'null:', md.base_revision_id)
659
661
        lines = md.to_lines()
660
662
        md2 = merge_directive.MergeDirective.from_lines(lines)
663
665
    def test_patch_verification(self):
664
666
        tree_a, tree_b, branch_c = self.make_trees()
665
667
        md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 60,
666
 
            tree_b.branch.base, patch_type='bundle',
667
 
            public_branch=tree_a.branch.base)
 
668
                               tree_b.branch.base, patch_type='bundle',
 
669
                               public_branch=tree_a.branch.base)
668
670
        lines = md.to_lines()
669
671
        md2 = merge_directive.MergeDirective.from_lines(lines)
670
672
        md2._verify_patch(tree_a.branch.repository)
736
738
            base_revision_id=tree.branch.last_revision(),
737
739
            message='This code rox')
738
740
        directive.compose_merge_request(client, 'jrandom@example.com',
739
 
            None, tree.branch)
 
741
                                        None, tree.branch)
740
742
        return client, directive
741
743
 
742
744
    def test_no_supports_body(self):
743
745
        test_hook = TestHook('foo')
744
746
        old_warn = trace.warning
745
747
        warnings = []
 
748
 
746
749
        def warn(*args):
747
750
            warnings.append(args)
748
751
        trace.warning = warn
749
752
        try:
750
753
            client, directive = self.compose_with_hooks([test_hook],
751
 
                supports_body=False)
 
754
                                                        supports_body=False)
752
755
        finally:
753
756
            trace.warning = old_warn
754
757
        self.assertEqual(0, len(test_hook.calls))