/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_log.py

  • Committer: Jelmer Vernooij
  • Date: 2018-02-18 21:42:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6859.
  • Revision ID: jelmer@jelmer.uk-20180218214257-jpevutp1wa30tz3v
Update TODO to reference Breezy, not Bazaar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_log.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from io import (
18
 
    BytesIO,
19
 
    StringIO,
20
 
    )
21
17
import os
22
 
import re
23
18
 
24
19
from .. import (
25
20
    branchbuilder,
32
27
    gpg,
33
28
    trace,
34
29
    )
 
30
from ..sixish import (
 
31
    BytesIO,
 
32
    )
35
33
 
36
34
 
37
35
class TestLogMixin(object):
43
41
        stamp is incremented at each commit.
44
42
        """
45
43
        if getattr(self, 'timestamp', None) is None:
46
 
            self.timestamp = 1132617600  # Mon 2005-11-22 00:00:00 +0000
 
44
            self.timestamp = 1132617600 # Mon 2005-11-22 00:00:00 +0000
47
45
        else:
48
 
            self.timestamp += 1  # 1 second between each commit
 
46
            self.timestamp += 1 # 1 second between each commit
49
47
        kwargs.setdefault('timestamp', self.timestamp)
50
 
        kwargs.setdefault('timezone', 0)  # UTC
 
48
        kwargs.setdefault('timezone', 0) # UTC
51
49
        kwargs.setdefault('committer', 'Joe Foo <joe@foo.com>')
52
50
 
53
51
        return wt.commit(message, **kwargs)
93
91
        """Helper method for LogFormatter tests"""
94
92
        b = wt.branch
95
93
        b.nick = 'test'
96
 
        self.build_tree_contents([('a', b'hello moto\n')])
97
 
        self.wt_commit(wt, 'simple log message', rev_id=b'a1')
98
 
        self.build_tree_contents([('b', b'goodbye\n')])
 
94
        self.build_tree_contents([('a', 'hello moto\n')])
 
95
        self.wt_commit(wt, 'simple log message', rev_id='a1')
 
96
        self.build_tree_contents([('b', 'goodbye\n')])
99
97
        wt.add('b')
100
 
        self.wt_commit(wt, 'multiline\nlog\nmessage\n', rev_id=b'a2')
 
98
        self.wt_commit(wt, 'multiline\nlog\nmessage\n', rev_id='a2')
101
99
 
102
 
        self.build_tree_contents([('c', b'just another manic monday\n')])
 
100
        self.build_tree_contents([('c', 'just another manic monday\n')])
103
101
        wt.add('c')
104
 
        self.wt_commit(wt, 'single line with trailing newline\n', rev_id=b'a3')
 
102
        self.wt_commit(wt, 'single line with trailing newline\n', rev_id='a3')
105
103
        return b
106
104
 
107
105
    def _prepare_tree_with_merges(self, with_tags=False):
109
107
        wt.lock_write()
110
108
        self.addCleanup(wt.unlock)
111
109
        wt.add('')
112
 
        self.wt_commit(wt, 'rev-1', rev_id=b'rev-1')
113
 
        self.wt_commit(wt, 'rev-merged', rev_id=b'rev-2a')
114
 
        wt.set_parent_ids([b'rev-1', b'rev-2a'])
115
 
        wt.branch.set_last_revision_info(1, b'rev-1')
116
 
        self.wt_commit(wt, 'rev-2', rev_id=b'rev-2b')
 
110
        self.wt_commit(wt, 'rev-1', rev_id='rev-1')
 
111
        self.wt_commit(wt, 'rev-merged', rev_id='rev-2a')
 
112
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
113
        wt.branch.set_last_revision_info(1, 'rev-1')
 
114
        self.wt_commit(wt, 'rev-2', rev_id='rev-2b')
117
115
        if with_tags:
118
116
            branch = wt.branch
119
 
            branch.tags.set_tag('v0.2', b'rev-2b')
120
 
            self.wt_commit(wt, 'rev-3', rev_id=b'rev-3')
121
 
            branch.tags.set_tag('v1.0rc1', b'rev-3')
122
 
            branch.tags.set_tag('v1.0', b'rev-3')
 
117
            branch.tags.set_tag('v0.2', 'rev-2b')
 
118
            self.wt_commit(wt, 'rev-3', rev_id='rev-3')
 
119
            branch.tags.set_tag('v1.0rc1', 'rev-3')
 
120
            branch.tags.set_tag('v1.0', 'rev-3')
123
121
        return wt
124
122
 
125
123
 
157
155
            # By default we expect an empty list
158
156
            expected = kw.get(n, [])
159
157
            # strip out only the path components
160
 
            got = [x.path[1] or x.path[0] for x in getattr(delta, n)]
 
158
            got = [x[0] for x in getattr(delta, n)]
161
159
            self.assertEqual(expected, got)
162
160
 
163
161
    def assertInvalidRevisonNumber(self, br, start, end):
179
177
        self.assertInvalidRevisonNumber(b, 2, 1)
180
178
        self.assertInvalidRevisonNumber(b, 1, 2)
181
179
        self.assertInvalidRevisonNumber(b, 0, 2)
 
180
        self.assertInvalidRevisonNumber(b, 1, 0)
182
181
        self.assertInvalidRevisonNumber(b, -1, 1)
183
182
        self.assertInvalidRevisonNumber(b, 1, -1)
184
 
        self.assertInvalidRevisonNumber(b, 1, 0)
185
183
 
186
184
    def test_empty_branch(self):
187
185
        wt = self.make_branch_and_tree('.')
222
220
 
223
221
    def test_commit_message_with_control_chars(self):
224
222
        wt = self.make_branch_and_tree('.')
225
 
        msg = u"All 8-bit chars: " + ''.join([chr(x) for x in range(256)])
 
223
        msg = u"All 8-bit chars: " +  ''.join([unichr(x) for x in range(256)])
226
224
        msg = msg.replace(u'\r', u'\n')
227
225
        wt.commit(msg)
228
226
        lf = LogCatcher()
240
238
        # newline conversion, neither LF (\x0A) nor CR (\x0D) are
241
239
        # included in the test commit message, even though they are
242
240
        # valid XML 1.0 characters.
243
 
        msg = "\x09" + ''.join([chr(x) for x in range(0x20, 256)])
 
241
        msg = "\x09" + ''.join([unichr(x) for x in range(0x20, 256)])
244
242
        wt.commit(msg)
245
243
        lf = LogCatcher()
246
244
        log.show_log(wt.branch, lf, verbose=True)
256
254
        wt.commit(message='add file1 and file2')
257
255
        self.run_bzr('branch parent child')
258
256
        os.unlink('child/file1')
259
 
        with open('child/file2', 'wb') as f:
260
 
            f.write(b'hello\n')
 
257
        with file('child/file2', 'wb') as f: f.write('hello\n')
261
258
        self.run_bzr(['commit', '-m', 'remove file1 and modify file2',
262
 
                      'child'])
 
259
            'child'])
263
260
        os.chdir('parent')
264
261
        self.run_bzr('merge ../child')
265
262
        wt.commit('merge child branch')
295
292
        merger = trunk.controldir.sprout('merger').open_workingtree()
296
293
        self.build_tree_contents([
297
294
            ('adder/dir/',),
298
 
            ('adder/dir/file', b'foo'),
 
295
            ('adder/dir/file', 'foo'),
299
296
            ])
300
297
        adder.add(['dir', 'dir/file'])
301
298
        adder.commit('added dir')                           # 1.1.1
305
302
        merger.commit('merged trunk into merger')           # 1.2.1
306
303
        # Commits are processed in increments of 200 revisions, so
307
304
        # make sure the two merges into trunk are in different chunks.
308
 
        for i in range(200):
 
305
        for i in xrange(200):
309
306
            trunk.commit('intermediate commit %d' % i)      # 3-202
310
307
        trunk.merge_from_branch(merger.branch)
311
308
        trunk.commit('merged merger into trunk')            # 203
320
317
 
321
318
 
322
319
class TestFormatSignatureValidity(tests.TestCaseWithTransport):
323
 
 
324
 
    def verify_revision_signature(self, revid, gpg_strategy):
325
 
        return (gpg.SIGNATURE_VALID,
 
320
    class UTFLoopbackGPGStrategy(gpg.LoopbackGPGStrategy):
 
321
        def verify(self, content, testament):
 
322
            return (gpg.SIGNATURE_VALID,
326
323
                u'UTF8 Test \xa1\xb1\xc1\xd1\xe1\xf1 <jrandom@example.com>')
327
324
 
 
325
    def has_signature_for_revision_id(self, revision_id):
 
326
        return True
 
327
 
 
328
    def get_signature_text(self, revision_id):
 
329
        return ''
 
330
 
328
331
    def test_format_signature_validity_utf(self):
329
332
        """Check that GPG signatures containing UTF-8 names are formatted
330
333
        correctly."""
 
334
        # Monkey patch to use our UTF-8 generating GPGStrategy
 
335
        self.overrideAttr(gpg, 'GPGStrategy', self.UTFLoopbackGPGStrategy)
331
336
        wt = self.make_branch_and_tree('.')
332
337
        revid = wt.commit('empty commit')
333
338
        repo = wt.branch.repository
334
339
        # Monkey patch out checking if this rev is actually signed, since we
335
340
        # can't sign it without a heavier TestCase and LoopbackGPGStrategy
336
341
        # doesn't care anyways.
337
 
        self.overrideAttr(repo, 'verify_revision_signature',
338
 
                          self.verify_revision_signature)
 
342
        self.overrideAttr(repo, 'has_signature_for_revision_id',
 
343
                self.has_signature_for_revision_id)
 
344
        self.overrideAttr(repo, 'get_signature_text', self.get_signature_text)
339
345
        out = log.format_signature_validity(revid, wt.branch)
340
346
        self.assertEqual(
341
 
            u'valid signature from UTF8 Test \xa1\xb1\xc1\xd1\xe1\xf1 <jrandom@example.com>',
342
 
            out)
 
347
u'valid signature from UTF8 Test \xa1\xb1\xc1\xd1\xe1\xf1 <jrandom@example.com>',
 
348
                out)
343
349
 
344
350
 
345
351
class TestShortLogFormatter(TestCaseForLogFormatter):
347
353
    def test_trailing_newlines(self):
348
354
        wt = self.make_branch_and_tree('.')
349
355
        b = self.make_commits_with_trailing_newlines(wt)
350
 
        self.assertFormatterResult(b"""\
 
356
        self.assertFormatterResult("""\
351
357
    3 Joe Foo\t2005-11-22
352
358
      single line with trailing newline
353
359
 
360
366
      simple log message
361
367
 
362
368
""",
363
 
                                   b, log.ShortLogFormatter)
 
369
            b, log.ShortLogFormatter)
364
370
 
365
371
    def test_short_log_with_merges(self):
366
372
        wt = self._prepare_tree_with_merges()
367
 
        self.assertFormatterResult(b"""\
 
373
        self.assertFormatterResult("""\
368
374
    2 Joe Foo\t2005-11-22 [merge]
369
375
      rev-2
370
376
 
372
378
      rev-1
373
379
 
374
380
""",
375
 
                                   wt.branch, log.ShortLogFormatter)
 
381
            wt.branch, log.ShortLogFormatter)
376
382
 
377
383
    def test_short_log_with_merges_and_advice(self):
378
384
        wt = self._prepare_tree_with_merges()
379
 
        self.assertFormatterResult(b"""\
 
385
        self.assertFormatterResult("""\
380
386
    2 Joe Foo\t2005-11-22 [merge]
381
387
      rev-2
382
388
 
385
391
 
386
392
Use --include-merged or -n0 to see merged revisions.
387
393
""",
388
 
                                   wt.branch, log.ShortLogFormatter,
389
 
                                   formatter_kwargs=dict(show_advice=True))
 
394
            wt.branch, log.ShortLogFormatter,
 
395
            formatter_kwargs=dict(show_advice=True))
390
396
 
391
397
    def test_short_log_with_merges_and_range(self):
392
398
        wt = self._prepare_tree_with_merges()
393
 
        self.wt_commit(wt, 'rev-3a', rev_id=b'rev-3a')
394
 
        wt.branch.set_last_revision_info(2, b'rev-2b')
395
 
        wt.set_parent_ids([b'rev-2b', b'rev-3a'])
396
 
        self.wt_commit(wt, 'rev-3b', rev_id=b'rev-3b')
397
 
        self.assertFormatterResult(b"""\
 
399
        self.wt_commit(wt, 'rev-3a', rev_id='rev-3a')
 
400
        wt.branch.set_last_revision_info(2, 'rev-2b')
 
401
        wt.set_parent_ids(['rev-2b', 'rev-3a'])
 
402
        self.wt_commit(wt, 'rev-3b', rev_id='rev-3b')
 
403
        self.assertFormatterResult("""\
398
404
    3 Joe Foo\t2005-11-22 [merge]
399
405
      rev-3b
400
406
 
402
408
      rev-2
403
409
 
404
410
""",
405
 
                                   wt.branch, log.ShortLogFormatter,
406
 
                                   show_log_kwargs=dict(start_revision=2, end_revision=3))
 
411
            wt.branch, log.ShortLogFormatter,
 
412
            show_log_kwargs=dict(start_revision=2, end_revision=3))
407
413
 
408
414
    def test_short_log_with_tags(self):
409
415
        wt = self._prepare_tree_with_merges(with_tags=True)
410
 
        self.assertFormatterResult(b"""\
 
416
        self.assertFormatterResult("""\
411
417
    3 Joe Foo\t2005-11-22 {v1.0, v1.0rc1}
412
418
      rev-3
413
419
 
418
424
      rev-1
419
425
 
420
426
""",
421
 
                                   wt.branch, log.ShortLogFormatter)
 
427
            wt.branch, log.ShortLogFormatter)
422
428
 
423
429
    def test_short_log_single_merge_revision(self):
424
430
        wt = self._prepare_tree_with_merges()
425
431
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
426
432
        rev = revspec.in_history(wt.branch)
427
 
        self.assertFormatterResult(b"""\
 
433
        self.assertFormatterResult("""\
428
434
      1.1.1 Joe Foo\t2005-11-22
429
435
            rev-merged
430
436
 
431
437
""",
432
 
                                   wt.branch, log.ShortLogFormatter,
433
 
                                   show_log_kwargs=dict(start_revision=rev, end_revision=rev))
 
438
            wt.branch, log.ShortLogFormatter,
 
439
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
434
440
 
435
441
    def test_show_ids(self):
436
442
        wt = self.make_branch_and_tree('parent')
437
443
        self.build_tree(['parent/f1', 'parent/f2'])
438
444
        wt.add(['f1', 'f2'])
439
 
        self.wt_commit(wt, 'first post', rev_id=b'a')
 
445
        self.wt_commit(wt, 'first post', rev_id='a')
440
446
        child_wt = wt.controldir.sprout('child').open_workingtree()
441
 
        self.wt_commit(child_wt, 'branch 1 changes', rev_id=b'b')
 
447
        self.wt_commit(child_wt, 'branch 1 changes', rev_id='b')
442
448
        wt.merge_from_branch(child_wt.branch)
443
 
        self.wt_commit(wt, 'merge branch 1', rev_id=b'c')
444
 
        self.assertFormatterResult(b"""\
 
449
        self.wt_commit(wt, 'merge branch 1', rev_id='c')
 
450
        self.assertFormatterResult("""\
445
451
    2 Joe Foo\t2005-11-22 [merge]
446
452
      revision-id:c
447
453
      merge branch 1
455
461
      first post
456
462
 
457
463
""",
458
 
                                   wt.branch, log.ShortLogFormatter,
459
 
                                   formatter_kwargs=dict(levels=0, show_ids=True))
 
464
            wt.branch, log.ShortLogFormatter,
 
465
            formatter_kwargs=dict(levels=0, show_ids=True))
460
466
 
461
467
 
462
468
class TestShortLogFormatterWithMergeRevisions(TestCaseForLogFormatter):
466
472
        # Note that the 1.1.1 indenting is in fact correct given that
467
473
        # the revision numbers are right justified within 5 characters
468
474
        # for mainline revnos and 9 characters for dotted revnos.
469
 
        self.assertFormatterResult(b"""\
 
475
        self.assertFormatterResult("""\
470
476
    2 Joe Foo\t2005-11-22 [merge]
471
477
      rev-2
472
478
 
477
483
      rev-1
478
484
 
479
485
""",
480
 
                                   wt.branch, log.ShortLogFormatter,
481
 
                                   formatter_kwargs=dict(levels=0))
 
486
            wt.branch, log.ShortLogFormatter,
 
487
            formatter_kwargs=dict(levels=0))
482
488
 
483
489
    def test_short_merge_revs_log_single_merge_revision(self):
484
490
        wt = self._prepare_tree_with_merges()
485
491
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
486
492
        rev = revspec.in_history(wt.branch)
487
 
        self.assertFormatterResult(b"""\
 
493
        self.assertFormatterResult("""\
488
494
      1.1.1 Joe Foo\t2005-11-22
489
495
            rev-merged
490
496
 
491
497
""",
492
 
                                   wt.branch, log.ShortLogFormatter,
493
 
                                   formatter_kwargs=dict(levels=0),
494
 
                                   show_log_kwargs=dict(start_revision=rev, end_revision=rev))
 
498
            wt.branch, log.ShortLogFormatter,
 
499
            formatter_kwargs=dict(levels=0),
 
500
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
495
501
 
496
502
 
497
503
class TestLongLogFormatter(TestCaseForLogFormatter):
502
508
        bug #4676
503
509
        """
504
510
        wt = self.make_standard_commit('test_verbose_log', authors=[])
505
 
        self.assertFormatterResult(b'''\
 
511
        self.assertFormatterResult('''\
506
512
------------------------------------------------------------
507
513
revno: 1
508
514
committer: Lorem Ipsum <test@example.com>
513
519
added:
514
520
  a
515
521
''',
516
 
                                   wt.branch, log.LongLogFormatter,
517
 
                                   show_log_kwargs=dict(verbose=True))
 
522
            wt.branch, log.LongLogFormatter,
 
523
            show_log_kwargs=dict(verbose=True))
518
524
 
519
525
    def test_merges_are_indented_by_level(self):
520
526
        wt = self.make_branch_and_tree('parent')
521
527
        self.wt_commit(wt, 'first post')
522
528
        child_wt = wt.controldir.sprout('child').open_workingtree()
523
529
        self.wt_commit(child_wt, 'branch 1')
524
 
        smallerchild_wt = wt.controldir.sprout(
525
 
            'smallerchild').open_workingtree()
 
530
        smallerchild_wt = wt.controldir.sprout('smallerchild').open_workingtree()
526
531
        self.wt_commit(smallerchild_wt, 'branch 2')
527
532
        child_wt.merge_from_branch(smallerchild_wt.branch)
528
533
        self.wt_commit(child_wt, 'merge branch 2')
529
534
        wt.merge_from_branch(child_wt.branch)
530
535
        self.wt_commit(wt, 'merge branch 1')
531
 
        self.assertFormatterResult(b"""\
 
536
        self.assertFormatterResult("""\
532
537
------------------------------------------------------------
533
538
revno: 2 [merge]
534
539
committer: Joe Foo <joe@foo.com>
565
570
message:
566
571
  first post
567
572
""",
568
 
                                   wt.branch, log.LongLogFormatter,
569
 
                                   formatter_kwargs=dict(levels=0),
570
 
                                   show_log_kwargs=dict(verbose=True))
 
573
            wt.branch, log.LongLogFormatter,
 
574
            formatter_kwargs=dict(levels=0),
 
575
            show_log_kwargs=dict(verbose=True))
571
576
 
572
577
    def test_verbose_merge_revisions_contain_deltas(self):
573
578
        wt = self.make_branch_and_tree('parent')
576
581
        self.wt_commit(wt, 'first post')
577
582
        child_wt = wt.controldir.sprout('child').open_workingtree()
578
583
        os.unlink('child/f1')
579
 
        self.build_tree_contents([('child/f2', b'hello\n')])
 
584
        self.build_tree_contents([('child/f2', 'hello\n')])
580
585
        self.wt_commit(child_wt, 'removed f1 and modified f2')
581
586
        wt.merge_from_branch(child_wt.branch)
582
587
        self.wt_commit(wt, 'merge branch 1')
583
 
        self.assertFormatterResult(b"""\
 
588
        self.assertFormatterResult("""\
584
589
------------------------------------------------------------
585
590
revno: 2 [merge]
586
591
committer: Joe Foo <joe@foo.com>
614
619
  f1
615
620
  f2
616
621
""",
617
 
                                   wt.branch, log.LongLogFormatter,
618
 
                                   formatter_kwargs=dict(levels=0),
619
 
                                   show_log_kwargs=dict(verbose=True))
 
622
            wt.branch, log.LongLogFormatter,
 
623
            formatter_kwargs=dict(levels=0),
 
624
            show_log_kwargs=dict(verbose=True))
620
625
 
621
626
    def test_trailing_newlines(self):
622
627
        wt = self.make_branch_and_tree('.')
623
628
        b = self.make_commits_with_trailing_newlines(wt)
624
 
        self.assertFormatterResult(b"""\
 
629
        self.assertFormatterResult("""\
625
630
------------------------------------------------------------
626
631
revno: 3
627
632
committer: Joe Foo <joe@foo.com>
646
651
message:
647
652
  simple log message
648
653
""",
649
 
                                   b, log.LongLogFormatter)
 
654
        b, log.LongLogFormatter)
650
655
 
651
656
    def test_author_in_log(self):
652
657
        """Log includes the author name if it's set in
653
658
        the revision properties
654
659
        """
655
660
        wt = self.make_standard_commit('test_author_log',
656
 
                                       authors=['John Doe <jdoe@example.com>',
657
 
                                                'Jane Rey <jrey@example.com>'])
658
 
        self.assertFormatterResult(b"""\
 
661
            authors=['John Doe <jdoe@example.com>',
 
662
                     'Jane Rey <jrey@example.com>'])
 
663
        self.assertFormatterResult("""\
659
664
------------------------------------------------------------
660
665
revno: 1
661
666
author: John Doe <jdoe@example.com>, Jane Rey <jrey@example.com>
665
670
message:
666
671
  add a
667
672
""",
668
 
                                   wt.branch, log.LongLogFormatter)
 
673
        wt.branch, log.LongLogFormatter)
669
674
 
670
675
    def test_properties_in_log(self):
671
676
        """Log includes the custom properties returned by the registered
672
677
        handlers.
673
678
        """
674
679
        wt = self.make_standard_commit('test_properties_in_log')
675
 
 
676
680
        def trivial_custom_prop_handler(revision):
677
 
            return {'test_prop': 'test_value'}
 
681
            return {'test_prop':'test_value'}
678
682
 
679
683
        # Cleaned up in setUp()
680
684
        log.properties_handler_registry.register(
681
685
            'trivial_custom_prop_handler',
682
686
            trivial_custom_prop_handler)
683
 
        self.assertFormatterResult(b"""\
 
687
        self.assertFormatterResult("""\
684
688
------------------------------------------------------------
685
689
revno: 1
686
690
test_prop: test_value
691
695
message:
692
696
  add a
693
697
""",
694
 
                                   wt.branch, log.LongLogFormatter)
 
698
            wt.branch, log.LongLogFormatter)
695
699
 
696
700
    def test_properties_in_short_log(self):
697
701
        """Log includes the custom properties returned by the registered
698
702
        handlers.
699
703
        """
700
704
        wt = self.make_standard_commit('test_properties_in_short_log')
701
 
 
702
705
        def trivial_custom_prop_handler(revision):
703
 
            return {'test_prop': 'test_value'}
 
706
            return {'test_prop':'test_value'}
704
707
 
705
708
        log.properties_handler_registry.register(
706
709
            'trivial_custom_prop_handler',
707
710
            trivial_custom_prop_handler)
708
 
        self.assertFormatterResult(b"""\
 
711
        self.assertFormatterResult("""\
709
712
    1 John Doe\t2005-11-22
710
713
      test_prop: test_value
711
714
      add a
712
715
 
713
716
""",
714
 
                                   wt.branch, log.ShortLogFormatter)
 
717
            wt.branch, log.ShortLogFormatter)
715
718
 
716
719
    def test_error_in_properties_handler(self):
717
720
        """Log includes the custom properties returned by the registered
718
721
        handlers.
719
722
        """
720
723
        wt = self.make_standard_commit('error_in_properties_handler',
721
 
                                       revprops={u'first_prop': 'first_value'})
 
724
            revprops={'first_prop':'first_value'})
722
725
        sio = self.make_utf8_encoded_stringio()
723
726
        formatter = log.LongLogFormatter(to_file=sio)
724
 
 
725
727
        def trivial_custom_prop_handler(revision):
726
728
            raise Exception("a test error")
727
729
 
728
730
        log.properties_handler_registry.register(
729
731
            'trivial_custom_prop_handler',
730
732
            trivial_custom_prop_handler)
731
 
        log.show_log(wt.branch, formatter)
732
 
        self.assertContainsRe(
733
 
            sio.getvalue(), b'brz: ERROR: Exception: a test error')
 
733
        self.assertRaises(Exception, log.show_log, wt.branch, formatter,)
734
734
 
735
735
    def test_properties_handler_bad_argument(self):
736
736
        wt = self.make_standard_commit('bad_argument',
737
 
                                       revprops={u'a_prop': 'test_value'})
 
737
              revprops={'a_prop':'test_value'})
738
738
        sio = self.make_utf8_encoded_stringio()
739
739
        formatter = log.LongLogFormatter(to_file=sio)
740
 
 
741
740
        def bad_argument_prop_handler(revision):
742
 
            return {'custom_prop_name': revision.properties['a_prop']}
 
741
            return {'custom_prop_name':revision.properties['a_prop']}
743
742
 
744
743
        log.properties_handler_registry.register(
745
744
            'bad_argument_prop_handler',
750
749
 
751
750
        revision = wt.branch.repository.get_revision(wt.branch.last_revision())
752
751
        formatter.show_properties(revision, '')
753
 
        self.assertEqualDiff(b'custom_prop_name: test_value\n',
 
752
        self.assertEqualDiff('''custom_prop_name: test_value\n''',
754
753
                             sio.getvalue())
755
754
 
756
755
    def test_show_ids(self):
757
756
        wt = self.make_branch_and_tree('parent')
758
757
        self.build_tree(['parent/f1', 'parent/f2'])
759
758
        wt.add(['f1', 'f2'])
760
 
        self.wt_commit(wt, 'first post', rev_id=b'a')
 
759
        self.wt_commit(wt, 'first post', rev_id='a')
761
760
        child_wt = wt.controldir.sprout('child').open_workingtree()
762
 
        self.wt_commit(child_wt, 'branch 1 changes', rev_id=b'b')
 
761
        self.wt_commit(child_wt, 'branch 1 changes', rev_id='b')
763
762
        wt.merge_from_branch(child_wt.branch)
764
 
        self.wt_commit(wt, 'merge branch 1', rev_id=b'c')
765
 
        self.assertFormatterResult(b"""\
 
763
        self.wt_commit(wt, 'merge branch 1', rev_id='c')
 
764
        self.assertFormatterResult("""\
766
765
------------------------------------------------------------
767
766
revno: 2 [merge]
768
767
revision-id: c
791
790
message:
792
791
  first post
793
792
""",
794
 
                                   wt.branch, log.LongLogFormatter,
795
 
                                   formatter_kwargs=dict(levels=0, show_ids=True))
 
793
            wt.branch, log.LongLogFormatter,
 
794
            formatter_kwargs=dict(levels=0, show_ids=True))
796
795
 
797
796
 
798
797
class TestLongLogFormatterWithoutMergeRevisions(TestCaseForLogFormatter):
803
802
        bug #4676
804
803
        """
805
804
        wt = self.make_standard_commit('test_long_verbose_log', authors=[])
806
 
        self.assertFormatterResult(b"""\
 
805
        self.assertFormatterResult("""\
807
806
------------------------------------------------------------
808
807
revno: 1
809
808
committer: Lorem Ipsum <test@example.com>
814
813
added:
815
814
  a
816
815
""",
817
 
                                   wt.branch, log.LongLogFormatter,
818
 
                                   formatter_kwargs=dict(levels=1),
819
 
                                   show_log_kwargs=dict(verbose=True))
 
816
            wt.branch, log.LongLogFormatter,
 
817
            formatter_kwargs=dict(levels=1),
 
818
            show_log_kwargs=dict(verbose=True))
820
819
 
821
820
    def test_long_verbose_contain_deltas(self):
822
821
        wt = self.make_branch_and_tree('parent')
825
824
        self.wt_commit(wt, 'first post')
826
825
        child_wt = wt.controldir.sprout('child').open_workingtree()
827
826
        os.unlink('child/f1')
828
 
        self.build_tree_contents([('child/f2', b'hello\n')])
 
827
        self.build_tree_contents([('child/f2', 'hello\n')])
829
828
        self.wt_commit(child_wt, 'removed f1 and modified f2')
830
829
        wt.merge_from_branch(child_wt.branch)
831
830
        self.wt_commit(wt, 'merge branch 1')
832
 
        self.assertFormatterResult(b"""\
 
831
        self.assertFormatterResult("""\
833
832
------------------------------------------------------------
834
833
revno: 2 [merge]
835
834
committer: Joe Foo <joe@foo.com>
852
851
  f1
853
852
  f2
854
853
""",
855
 
                                   wt.branch, log.LongLogFormatter,
856
 
                                   formatter_kwargs=dict(levels=1),
857
 
                                   show_log_kwargs=dict(verbose=True))
 
854
            wt.branch, log.LongLogFormatter,
 
855
            formatter_kwargs=dict(levels=1),
 
856
            show_log_kwargs=dict(verbose=True))
858
857
 
859
858
    def test_long_trailing_newlines(self):
860
859
        wt = self.make_branch_and_tree('.')
861
860
        b = self.make_commits_with_trailing_newlines(wt)
862
 
        self.assertFormatterResult(b"""\
 
861
        self.assertFormatterResult("""\
863
862
------------------------------------------------------------
864
863
revno: 3
865
864
committer: Joe Foo <joe@foo.com>
884
883
message:
885
884
  simple log message
886
885
""",
887
 
                                   b, log.LongLogFormatter,
888
 
                                   formatter_kwargs=dict(levels=1))
 
886
        b, log.LongLogFormatter,
 
887
        formatter_kwargs=dict(levels=1))
889
888
 
890
889
    def test_long_author_in_log(self):
891
890
        """Log includes the author name if it's set in
892
891
        the revision properties
893
892
        """
894
893
        wt = self.make_standard_commit('test_author_log')
895
 
        self.assertFormatterResult(b"""\
 
894
        self.assertFormatterResult("""\
896
895
------------------------------------------------------------
897
896
revno: 1
898
897
author: John Doe <jdoe@example.com>
902
901
message:
903
902
  add a
904
903
""",
905
 
                                   wt.branch, log.LongLogFormatter,
906
 
                                   formatter_kwargs=dict(levels=1))
 
904
            wt.branch, log.LongLogFormatter,
 
905
            formatter_kwargs=dict(levels=1))
907
906
 
908
907
    def test_long_properties_in_log(self):
909
908
        """Log includes the custom properties returned by the registered
910
909
        handlers.
911
910
        """
912
911
        wt = self.make_standard_commit('test_properties_in_log')
913
 
 
914
912
        def trivial_custom_prop_handler(revision):
915
 
            return {'test_prop': 'test_value'}
 
913
            return {'test_prop':'test_value'}
916
914
 
917
915
        log.properties_handler_registry.register(
918
916
            'trivial_custom_prop_handler',
919
917
            trivial_custom_prop_handler)
920
 
        self.assertFormatterResult(b"""\
 
918
        self.assertFormatterResult("""\
921
919
------------------------------------------------------------
922
920
revno: 1
923
921
test_prop: test_value
928
926
message:
929
927
  add a
930
928
""",
931
 
                                   wt.branch, log.LongLogFormatter,
932
 
                                   formatter_kwargs=dict(levels=1))
 
929
            wt.branch, log.LongLogFormatter,
 
930
            formatter_kwargs=dict(levels=1))
933
931
 
934
932
 
935
933
class TestLineLogFormatter(TestCaseForLogFormatter):
940
938
        bug #5162
941
939
        """
942
940
        wt = self.make_standard_commit('test-line-log',
943
 
                                       committer='Line-Log-Formatter Tester <test@line.log>',
944
 
                                       authors=[])
945
 
        self.assertFormatterResult(b"""\
 
941
                committer='Line-Log-Formatter Tester <test@line.log>',
 
942
                authors=[])
 
943
        self.assertFormatterResult("""\
946
944
1: Line-Log-Formatte... 2005-11-22 add a
947
945
""",
948
 
                                   wt.branch, log.LineLogFormatter)
 
946
            wt.branch, log.LineLogFormatter)
949
947
 
950
948
    def test_trailing_newlines(self):
951
949
        wt = self.make_branch_and_tree('.')
952
950
        b = self.make_commits_with_trailing_newlines(wt)
953
 
        self.assertFormatterResult(b"""\
 
951
        self.assertFormatterResult("""\
954
952
3: Joe Foo 2005-11-22 single line with trailing newline
955
953
2: Joe Foo 2005-11-22 multiline
956
954
1: Joe Foo 2005-11-22 simple log message
957
955
""",
958
 
                                   b, log.LineLogFormatter)
 
956
            b, log.LineLogFormatter)
959
957
 
960
958
    def test_line_log_single_merge_revision(self):
961
959
        wt = self._prepare_tree_with_merges()
962
960
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
963
961
        rev = revspec.in_history(wt.branch)
964
 
        self.assertFormatterResult(b"""\
 
962
        self.assertFormatterResult("""\
965
963
1.1.1: Joe Foo 2005-11-22 rev-merged
966
964
""",
967
 
                                   wt.branch, log.LineLogFormatter,
968
 
                                   show_log_kwargs=dict(start_revision=rev, end_revision=rev))
 
965
            wt.branch, log.LineLogFormatter,
 
966
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
969
967
 
970
968
    def test_line_log_with_tags(self):
971
969
        wt = self._prepare_tree_with_merges(with_tags=True)
972
 
        self.assertFormatterResult(b"""\
 
970
        self.assertFormatterResult("""\
973
971
3: Joe Foo 2005-11-22 {v1.0, v1.0rc1} rev-3
974
972
2: Joe Foo 2005-11-22 [merge] {v0.2} rev-2
975
973
1: Joe Foo 2005-11-22 rev-1
976
974
""",
977
 
                                   wt.branch, log.LineLogFormatter)
 
975
            wt.branch, log.LineLogFormatter)
978
976
 
979
977
 
980
978
class TestLineLogFormatterWithMergeRevisions(TestCaseForLogFormatter):
985
983
        bug #5162
986
984
        """
987
985
        wt = self.make_standard_commit('test-line-log',
988
 
                                       committer='Line-Log-Formatter Tester <test@line.log>',
989
 
                                       authors=[])
990
 
        self.assertFormatterResult(b"""\
 
986
                committer='Line-Log-Formatter Tester <test@line.log>',
 
987
                authors=[])
 
988
        self.assertFormatterResult("""\
991
989
1: Line-Log-Formatte... 2005-11-22 add a
992
990
""",
993
 
                                   wt.branch, log.LineLogFormatter)
 
991
            wt.branch, log.LineLogFormatter)
994
992
 
995
993
    def test_line_merge_revs_log_single_merge_revision(self):
996
994
        wt = self._prepare_tree_with_merges()
997
995
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
998
996
        rev = revspec.in_history(wt.branch)
999
 
        self.assertFormatterResult(b"""\
 
997
        self.assertFormatterResult("""\
1000
998
1.1.1: Joe Foo 2005-11-22 rev-merged
1001
999
""",
1002
 
                                   wt.branch, log.LineLogFormatter,
1003
 
                                   formatter_kwargs=dict(levels=0),
1004
 
                                   show_log_kwargs=dict(start_revision=rev, end_revision=rev))
 
1000
            wt.branch, log.LineLogFormatter,
 
1001
            formatter_kwargs=dict(levels=0),
 
1002
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
1005
1003
 
1006
1004
    def test_line_merge_revs_log_with_merges(self):
1007
1005
        wt = self._prepare_tree_with_merges()
1008
 
        self.assertFormatterResult(b"""\
 
1006
        self.assertFormatterResult("""\
1009
1007
2: Joe Foo 2005-11-22 [merge] rev-2
1010
1008
  1.1.1: Joe Foo 2005-11-22 rev-merged
1011
1009
1: Joe Foo 2005-11-22 rev-1
1012
1010
""",
1013
 
                                   wt.branch, log.LineLogFormatter,
1014
 
                                   formatter_kwargs=dict(levels=0))
 
1011
            wt.branch, log.LineLogFormatter,
 
1012
            formatter_kwargs=dict(levels=0))
1015
1013
 
1016
1014
 
1017
1015
class TestGnuChangelogFormatter(TestCaseForLogFormatter):
1018
1016
 
1019
1017
    def test_gnu_changelog(self):
1020
1018
        wt = self.make_standard_commit('nicky', authors=[])
1021
 
        self.assertFormatterResult(b'''\
 
1019
        self.assertFormatterResult('''\
1022
1020
2005-11-22  Lorem Ipsum  <test@example.com>
1023
1021
 
1024
1022
\tadd a
1025
1023
 
1026
1024
''',
1027
 
                                   wt.branch, log.GnuChangelogLogFormatter)
 
1025
            wt.branch, log.GnuChangelogLogFormatter)
1028
1026
 
1029
1027
    def test_with_authors(self):
1030
1028
        wt = self.make_standard_commit('nicky',
1031
 
                                       authors=['Fooa Fooz <foo@example.com>',
1032
 
                                                'Bari Baro <bar@example.com>'])
1033
 
        self.assertFormatterResult(b'''\
 
1029
            authors=['Fooa Fooz <foo@example.com>',
 
1030
                     'Bari Baro <bar@example.com>'])
 
1031
        self.assertFormatterResult('''\
1034
1032
2005-11-22  Fooa Fooz  <foo@example.com>
1035
1033
 
1036
1034
\tadd a
1037
1035
 
1038
1036
''',
1039
 
                                   wt.branch, log.GnuChangelogLogFormatter)
 
1037
            wt.branch, log.GnuChangelogLogFormatter)
1040
1038
 
1041
1039
    def test_verbose(self):
1042
1040
        wt = self.make_standard_commit('nicky')
1043
 
        self.assertFormatterResult(b'''\
 
1041
        self.assertFormatterResult('''\
1044
1042
2005-11-22  John Doe  <jdoe@example.com>
1045
1043
 
1046
1044
\t* a:
1048
1046
\tadd a
1049
1047
 
1050
1048
''',
1051
 
                                   wt.branch, log.GnuChangelogLogFormatter,
1052
 
                                   show_log_kwargs=dict(verbose=True))
 
1049
            wt.branch, log.GnuChangelogLogFormatter,
 
1050
            show_log_kwargs=dict(verbose=True))
1053
1051
 
1054
1052
 
1055
1053
class TestShowChangedRevisions(tests.TestCaseWithTransport):
1058
1056
        tree = self.make_branch_and_tree('tree_a')
1059
1057
        self.build_tree(['tree_a/foo'])
1060
1058
        tree.add('foo')
1061
 
        tree.commit('bar', rev_id=b'bar-id')
 
1059
        tree.commit('bar', rev_id='bar-id')
1062
1060
        s = self.make_utf8_encoded_stringio()
1063
 
        log.show_changed_revisions(tree.branch, [], [b'bar-id'], s)
1064
 
        self.assertContainsRe(s.getvalue(), b'bar')
1065
 
        self.assertNotContainsRe(s.getvalue(), b'foo')
 
1061
        log.show_changed_revisions(tree.branch, [], ['bar-id'], s)
 
1062
        self.assertContainsRe(s.getvalue(), 'bar')
 
1063
        self.assertNotContainsRe(s.getvalue(), 'foo')
1066
1064
 
1067
1065
 
1068
1066
class TestLogFormatter(tests.TestCase):
1069
1067
 
1070
1068
    def setUp(self):
1071
1069
        super(TestLogFormatter, self).setUp()
1072
 
        self.rev = revision.Revision(b'a-id')
 
1070
        self.rev = revision.Revision('a-id')
1073
1071
        self.lf = log.LogFormatter(None)
1074
1072
 
1075
1073
    def test_short_committer(self):
1123
1121
            Tests use (revno, depth) whil the API expects (revid, revno, depth).
1124
1122
            Since the revid is arbitrary, we just duplicate revno
1125
1123
            """
1126
 
            return [(r, r, d) for r, d in l]
 
1124
            return [ (r, r, d) for r, d in l]
1127
1125
        forward = complete_revisions(forward)
1128
 
        backward = complete_revisions(backward)
 
1126
        backward= complete_revisions(backward)
1129
1127
        self.assertEqual(forward, log.reverse_by_depth(backward))
1130
1128
 
 
1129
 
1131
1130
    def test_mainline_revisions(self):
1132
 
        self.assertReversed([('1', 0), ('2', 0)],
 
1131
        self.assertReversed([( '1', 0), ('2', 0)],
1133
1132
                            [('2', 0), ('1', 0)])
1134
1133
 
1135
1134
    def test_merged_revisions(self):
1136
 
        self.assertReversed([('1', 0), ('2', 0), ('2.2', 1), ('2.1', 1), ],
1137
 
                            [('2', 0), ('2.1', 1), ('2.2', 1), ('1', 0), ])
1138
 
 
 
1135
        self.assertReversed([('1', 0), ('2', 0), ('2.2', 1), ('2.1', 1),],
 
1136
                            [('2', 0), ('2.1', 1), ('2.2', 1), ('1', 0),])
1139
1137
    def test_shifted_merged_revisions(self):
1140
1138
        """Test irregular layout.
1141
1139
 
1142
1140
        Requesting revisions touching a file can produce "holes" in the depths.
1143
1141
        """
1144
 
        self.assertReversed([('1', 0), ('2', 0), ('1.1', 2), ('1.2', 2), ],
1145
 
                            [('2', 0), ('1.2', 2), ('1.1', 2), ('1', 0), ])
 
1142
        self.assertReversed([('1', 0), ('2', 0), ('1.1', 2), ('1.2', 2),],
 
1143
                            [('2', 0), ('1.2', 2), ('1.1', 2), ('1', 0),])
1146
1144
 
1147
1145
    def test_merged_without_child_revisions(self):
1148
1146
        """Test irregular layout.
1152
1150
        # When a revision of higher depth doesn't follow one of lower depth, we
1153
1151
        # assume a lower depth one is virtually there
1154
1152
        self.assertReversed([('1', 2), ('2', 2), ('3', 3), ('4', 4)],
1155
 
                            [('4', 4), ('3', 3), ('2', 2), ('1', 2), ])
 
1153
                            [('4', 4), ('3', 3), ('2', 2), ('1', 2),])
1156
1154
        # So we get the same order after reversing below even if the original
1157
1155
        # revisions are not in the same order.
1158
1156
        self.assertReversed([('1', 2), ('2', 2), ('3', 3), ('4', 4)],
1159
 
                            [('3', 3), ('4', 4), ('2', 2), ('1', 2), ])
 
1157
                            [('3', 3), ('4', 4), ('2', 2), ('1', 2),])
1160
1158
 
1161
1159
 
1162
1160
class TestHistoryChange(tests.TestCaseWithTransport):
1165
1163
        tree = self.make_branch_and_tree('tree')
1166
1164
        tree.lock_write()
1167
1165
        self.addCleanup(tree.unlock)
1168
 
        tree.commit('1a', rev_id=b'1a')
1169
 
        tree.commit('2a', rev_id=b'2a')
1170
 
        tree.commit('3a', rev_id=b'3a')
 
1166
        tree.commit('1a', rev_id='1a')
 
1167
        tree.commit('2a', rev_id='2a')
 
1168
        tree.commit('3a', rev_id='3a')
1171
1169
        return tree
1172
1170
 
1173
1171
    def setup_ab_tree(self):
1174
1172
        tree = self.setup_a_tree()
1175
 
        tree.set_last_revision(b'1a')
1176
 
        tree.branch.set_last_revision_info(1, b'1a')
1177
 
        tree.commit('2b', rev_id=b'2b')
1178
 
        tree.commit('3b', rev_id=b'3b')
 
1173
        tree.set_last_revision('1a')
 
1174
        tree.branch.set_last_revision_info(1, '1a')
 
1175
        tree.commit('2b', rev_id='2b')
 
1176
        tree.commit('3b', rev_id='3b')
1179
1177
        return tree
1180
1178
 
1181
1179
    def setup_ac_tree(self):
1182
1180
        tree = self.setup_a_tree()
1183
1181
        tree.set_last_revision(revision.NULL_REVISION)
1184
1182
        tree.branch.set_last_revision_info(0, revision.NULL_REVISION)
1185
 
        tree.commit('1c', rev_id=b'1c')
1186
 
        tree.commit('2c', rev_id=b'2c')
1187
 
        tree.commit('3c', rev_id=b'3c')
 
1183
        tree.commit('1c', rev_id='1c')
 
1184
        tree.commit('2c', rev_id='2c')
 
1185
        tree.commit('3c', rev_id='3c')
1188
1186
        return tree
1189
1187
 
1190
1188
    def test_all_new(self):
1191
1189
        tree = self.setup_ab_tree()
1192
 
        old, new = log.get_history_change(b'1a', b'3a', tree.branch.repository)
 
1190
        old, new = log.get_history_change('1a', '3a', tree.branch.repository)
1193
1191
        self.assertEqual([], old)
1194
 
        self.assertEqual([b'2a', b'3a'], new)
 
1192
        self.assertEqual(['2a', '3a'], new)
1195
1193
 
1196
1194
    def test_all_old(self):
1197
1195
        tree = self.setup_ab_tree()
1198
 
        old, new = log.get_history_change(b'3a', b'1a', tree.branch.repository)
 
1196
        old, new = log.get_history_change('3a', '1a', tree.branch.repository)
1199
1197
        self.assertEqual([], new)
1200
 
        self.assertEqual([b'2a', b'3a'], old)
 
1198
        self.assertEqual(['2a', '3a'], old)
1201
1199
 
1202
1200
    def test_null_old(self):
1203
1201
        tree = self.setup_ab_tree()
1204
1202
        old, new = log.get_history_change(revision.NULL_REVISION,
1205
 
                                          b'3a', tree.branch.repository)
 
1203
                                          '3a', tree.branch.repository)
1206
1204
        self.assertEqual([], old)
1207
 
        self.assertEqual([b'1a', b'2a', b'3a'], new)
 
1205
        self.assertEqual(['1a', '2a', '3a'], new)
1208
1206
 
1209
1207
    def test_null_new(self):
1210
1208
        tree = self.setup_ab_tree()
1211
 
        old, new = log.get_history_change(b'3a', revision.NULL_REVISION,
 
1209
        old, new = log.get_history_change('3a', revision.NULL_REVISION,
1212
1210
                                          tree.branch.repository)
1213
1211
        self.assertEqual([], new)
1214
 
        self.assertEqual([b'1a', b'2a', b'3a'], old)
 
1212
        self.assertEqual(['1a', '2a', '3a'], old)
1215
1213
 
1216
1214
    def test_diverged(self):
1217
1215
        tree = self.setup_ab_tree()
1218
 
        old, new = log.get_history_change(b'3a', b'3b', tree.branch.repository)
1219
 
        self.assertEqual(old, [b'2a', b'3a'])
1220
 
        self.assertEqual(new, [b'2b', b'3b'])
 
1216
        old, new = log.get_history_change('3a', '3b', tree.branch.repository)
 
1217
        self.assertEqual(old, ['2a', '3a'])
 
1218
        self.assertEqual(new, ['2b', '3b'])
1221
1219
 
1222
1220
    def test_unrelated(self):
1223
1221
        tree = self.setup_ac_tree()
1224
 
        old, new = log.get_history_change(b'3a', b'3c', tree.branch.repository)
1225
 
        self.assertEqual(old, [b'1a', b'2a', b'3a'])
1226
 
        self.assertEqual(new, [b'1c', b'2c', b'3c'])
 
1222
        old, new = log.get_history_change('3a', '3c', tree.branch.repository)
 
1223
        self.assertEqual(old, ['1a', '2a', '3a'])
 
1224
        self.assertEqual(new, ['1c', '2c', '3c'])
1227
1225
 
1228
1226
    def test_show_branch_change(self):
1229
1227
        tree = self.setup_ab_tree()
1230
 
        s = StringIO()
1231
 
        log.show_branch_change(tree.branch, s, 3, b'3a')
 
1228
        s = BytesIO()
 
1229
        log.show_branch_change(tree.branch, s, 3, '3a')
1232
1230
        self.assertContainsRe(s.getvalue(),
1233
 
                              '[*]{60}\nRemoved Revisions:\n(.|\n)*2a(.|\n)*3a(.|\n)*'
1234
 
                              '[*]{60}\n\nAdded Revisions:\n(.|\n)*2b(.|\n)*3b')
 
1231
            '[*]{60}\nRemoved Revisions:\n(.|\n)*2a(.|\n)*3a(.|\n)*'
 
1232
            '[*]{60}\n\nAdded Revisions:\n(.|\n)*2b(.|\n)*3b')
1235
1233
 
1236
1234
    def test_show_branch_change_no_change(self):
1237
1235
        tree = self.setup_ab_tree()
1238
 
        s = StringIO()
1239
 
        log.show_branch_change(tree.branch, s, 3, b'3b')
 
1236
        s = BytesIO()
 
1237
        log.show_branch_change(tree.branch, s, 3, '3b')
1240
1238
        self.assertEqual(s.getvalue(),
1241
 
                         'Nothing seems to have changed\n')
 
1239
            'Nothing seems to have changed\n')
1242
1240
 
1243
1241
    def test_show_branch_change_no_old(self):
1244
1242
        tree = self.setup_ab_tree()
1245
 
        s = StringIO()
1246
 
        log.show_branch_change(tree.branch, s, 2, b'2b')
 
1243
        s = BytesIO()
 
1244
        log.show_branch_change(tree.branch, s, 2, '2b')
1247
1245
        self.assertContainsRe(s.getvalue(), 'Added Revisions:')
1248
1246
        self.assertNotContainsRe(s.getvalue(), 'Removed Revisions:')
1249
1247
 
1250
1248
    def test_show_branch_change_no_new(self):
1251
1249
        tree = self.setup_ab_tree()
1252
 
        tree.branch.set_last_revision_info(2, b'2b')
1253
 
        s = StringIO()
1254
 
        log.show_branch_change(tree.branch, s, 3, b'3b')
 
1250
        tree.branch.set_last_revision_info(2, '2b')
 
1251
        s = BytesIO()
 
1252
        log.show_branch_change(tree.branch, s, 3, '3b')
1255
1253
        self.assertContainsRe(s.getvalue(), 'Removed Revisions:')
1256
1254
        self.assertNotContainsRe(s.getvalue(), 'Added Revisions:')
1257
1255
 
1264
1262
        self.addCleanup(tree.unlock)
1265
1263
        kwargs = {
1266
1264
            'committer': 'Joe Foo <joe@foo.com>',
1267
 
            'timestamp': 1132617600,  # Mon 2005-11-22 00:00:00 +0000
1268
 
            'timezone': 0,  # UTC
 
1265
            'timestamp': 1132617600, # Mon 2005-11-22 00:00:00 +0000
 
1266
            'timezone': 0, # UTC
1269
1267
        }
1270
 
        tree.commit('commit 1a', rev_id=b'1a', **kwargs)
1271
 
        tree.commit('commit 2a', rev_id=b'2a', **kwargs)
1272
 
        tree.commit('commit 3a', rev_id=b'3a', **kwargs)
 
1268
        tree.commit('commit 1a', rev_id='1a', **kwargs)
 
1269
        tree.commit('commit 2a', rev_id='2a', **kwargs)
 
1270
        tree.commit('commit 3a', rev_id='3a', **kwargs)
1273
1271
        return tree
1274
1272
 
1275
1273
    def setup_ab_tree(self):
1276
1274
        tree = self.setup_a_tree()
1277
 
        tree.set_last_revision(b'1a')
1278
 
        tree.branch.set_last_revision_info(1, b'1a')
 
1275
        tree.set_last_revision('1a')
 
1276
        tree.branch.set_last_revision_info(1, '1a')
1279
1277
        kwargs = {
1280
1278
            'committer': 'Joe Foo <joe@foo.com>',
1281
 
            'timestamp': 1132617600,  # Mon 2005-11-22 00:00:00 +0000
1282
 
            'timezone': 0,  # UTC
 
1279
            'timestamp': 1132617600, # Mon 2005-11-22 00:00:00 +0000
 
1280
            'timezone': 0, # UTC
1283
1281
        }
1284
 
        tree.commit('commit 2b', rev_id=b'2b', **kwargs)
1285
 
        tree.commit('commit 3b', rev_id=b'3b', **kwargs)
 
1282
        tree.commit('commit 2b', rev_id='2b', **kwargs)
 
1283
        tree.commit('commit 3b', rev_id='3b', **kwargs)
1286
1284
        return tree
1287
1285
 
1288
1286
    def test_one_revision(self):
1289
1287
        tree = self.setup_ab_tree()
1290
1288
        lf = LogCatcher()
1291
 
        rev = revisionspec.RevisionInfo(tree.branch, None, b'3a')
 
1289
        rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1292
1290
        log.show_log(tree.branch, lf, verbose=True, start_revision=rev,
1293
1291
                     end_revision=rev)
1294
1292
        self.assertEqual(1, len(lf.revisions))
1295
1293
        self.assertEqual(None, lf.revisions[0].revno)   # Out-of-branch
1296
 
        self.assertEqual(b'3a', lf.revisions[0].rev.revision_id)
 
1294
        self.assertEqual('3a', lf.revisions[0].rev.revision_id)
1297
1295
 
1298
1296
    def test_many_revisions(self):
1299
1297
        tree = self.setup_ab_tree()
1300
1298
        lf = LogCatcher()
1301
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, b'1a')
1302
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, b'3a')
 
1299
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
 
1300
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1303
1301
        log.show_log(tree.branch, lf, verbose=True, start_revision=start_rev,
1304
1302
                     end_revision=end_rev)
1305
1303
        self.assertEqual(3, len(lf.revisions))
1306
1304
        self.assertEqual(None, lf.revisions[0].revno)   # Out-of-branch
1307
 
        self.assertEqual(b'3a', lf.revisions[0].rev.revision_id)
 
1305
        self.assertEqual('3a', lf.revisions[0].rev.revision_id)
1308
1306
        self.assertEqual(None, lf.revisions[1].revno)   # Out-of-branch
1309
 
        self.assertEqual(b'2a', lf.revisions[1].rev.revision_id)
 
1307
        self.assertEqual('2a', lf.revisions[1].rev.revision_id)
1310
1308
        self.assertEqual('1', lf.revisions[2].revno)    # In-branch
1311
1309
 
1312
1310
    def test_long_format(self):
1313
1311
        tree = self.setup_ab_tree()
1314
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, b'1a')
1315
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, b'3a')
1316
 
        self.assertFormatterResult(b"""\
 
1312
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
 
1313
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
 
1314
        self.assertFormatterResult("""\
1317
1315
------------------------------------------------------------
1318
1316
revision-id: 3a
1319
1317
committer: Joe Foo <joe@foo.com>
1336
1334
message:
1337
1335
  commit 1a
1338
1336
""",
1339
 
                                   tree.branch, log.LongLogFormatter, show_log_kwargs={
1340
 
                                       'start_revision': start_rev, 'end_revision': end_rev
1341
 
                                       })
 
1337
            tree.branch, log.LongLogFormatter, show_log_kwargs={
 
1338
                'start_revision': start_rev, 'end_revision': end_rev
 
1339
            })
1342
1340
 
1343
1341
    def test_short_format(self):
1344
1342
        tree = self.setup_ab_tree()
1345
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, b'1a')
1346
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, b'3a')
1347
 
        self.assertFormatterResult(b"""\
 
1343
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
 
1344
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
 
1345
        self.assertFormatterResult("""\
1348
1346
      Joe Foo\t2005-11-22
1349
1347
      revision-id:3a
1350
1348
      commit 3a
1357
1355
      commit 1a
1358
1356
 
1359
1357
""",
1360
 
                                   tree.branch, log.ShortLogFormatter, show_log_kwargs={
1361
 
                                       'start_revision': start_rev, 'end_revision': end_rev
1362
 
                                       })
 
1358
            tree.branch, log.ShortLogFormatter, show_log_kwargs={
 
1359
                'start_revision': start_rev, 'end_revision': end_rev
 
1360
            })
1363
1361
 
1364
1362
    def test_line_format(self):
1365
1363
        tree = self.setup_ab_tree()
1366
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, b'1a')
1367
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, b'3a')
1368
 
        self.assertFormatterResult(b"""\
 
1364
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
 
1365
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
 
1366
        self.assertFormatterResult("""\
1369
1367
Joe Foo 2005-11-22 commit 3a
1370
1368
Joe Foo 2005-11-22 commit 2a
1371
1369
1: Joe Foo 2005-11-22 commit 1a
1372
1370
""",
1373
 
                                   tree.branch, log.LineLogFormatter, show_log_kwargs={
1374
 
                                       'start_revision': start_rev, 'end_revision': end_rev
1375
 
                                       })
 
1371
            tree.branch, log.LineLogFormatter, show_log_kwargs={
 
1372
                'start_revision': start_rev, 'end_revision': end_rev
 
1373
            })
1376
1374
 
1377
1375
 
1378
1376
class TestLogWithBugs(TestCaseForLogFormatter, TestLogMixin):
1388
1386
        tree = self.make_branch_and_tree(u'.')
1389
1387
        self.build_tree(['a', 'b'])
1390
1388
        tree.add('a')
1391
 
        self.wt_commit(tree, 'simple log message', rev_id=b'a1',
1392
 
                       revprops={u'bugs': 'test://bug/id fixed'})
 
1389
        self.wt_commit(tree, 'simple log message', rev_id='a1',
 
1390
                       revprops={'bugs': 'test://bug/id fixed'})
1393
1391
        tree.add('b')
1394
 
        self.wt_commit(tree, 'multiline\nlog\nmessage\n', rev_id=b'a2',
 
1392
        self.wt_commit(tree, 'multiline\nlog\nmessage\n', rev_id='a2',
1395
1393
                       authors=['Joe Bar <joe@bar.com>'],
1396
 
                       revprops={u'bugs': 'test://bug/id fixed\n'
 
1394
                       revprops={'bugs': 'test://bug/id fixed\n'
1397
1395
                                 'test://bug/2 fixed'})
1398
1396
        return tree
1399
1397
 
1400
 
    def test_bug_broken(self):
1401
 
        tree = self.make_branch_and_tree(u'.')
1402
 
        self.build_tree(['a', 'b'])
1403
 
        tree.add('a')
1404
 
        self.wt_commit(tree, 'simple log message', rev_id=b'a1',
1405
 
                       revprops={u'bugs': 'test://bua g/id fixed'})
1406
 
 
1407
 
        logfile = self.make_utf8_encoded_stringio()
1408
 
        formatter = log.LongLogFormatter(to_file=logfile)
1409
 
        log.show_log(tree.branch, formatter)
1410
 
 
1411
 
        self.assertContainsRe(
1412
 
            logfile.getvalue(),
1413
 
            b'brz: ERROR: breezy.bugtracker.InvalidLineInBugsProperty: '
1414
 
            b'Invalid line in bugs property: \'test://bua g/id fixed\'')
1415
 
 
1416
 
        text = logfile.getvalue()
1417
 
        self.assertEqualDiff(
1418
 
            text[text.index(b'-' * 60):],
1419
 
            b"""\
1420
 
------------------------------------------------------------
1421
 
revno: 1
1422
 
committer: Joe Foo <joe@foo.com>
1423
 
branch nick: work
1424
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1425
 
message:
1426
 
  simple log message
1427
 
""")
1428
1398
 
1429
1399
    def test_long_bugs(self):
1430
1400
        tree = self.make_commits_with_bugs()
1431
 
        self.assertFormatterResult(b"""\
 
1401
        self.assertFormatterResult("""\
1432
1402
------------------------------------------------------------
1433
1403
revno: 2
1434
1404
fixes bugs: test://bug/id test://bug/2
1449
1419
message:
1450
1420
  simple log message
1451
1421
""",
1452
 
                                   tree.branch, log.LongLogFormatter)
 
1422
            tree.branch, log.LongLogFormatter)
1453
1423
 
1454
1424
    def test_short_bugs(self):
1455
1425
        tree = self.make_commits_with_bugs()
1456
 
        self.assertFormatterResult(b"""\
 
1426
        self.assertFormatterResult("""\
1457
1427
    2 Joe Bar\t2005-11-22
1458
1428
      fixes bugs: test://bug/id test://bug/2
1459
1429
      multiline
1465
1435
      simple log message
1466
1436
 
1467
1437
""",
1468
 
                                   tree.branch, log.ShortLogFormatter)
 
1438
            tree.branch, log.ShortLogFormatter)
1469
1439
 
1470
1440
    def test_wrong_bugs_property(self):
1471
1441
        tree = self.make_branch_and_tree(u'.')
1472
1442
        self.build_tree(['foo'])
1473
 
        self.wt_commit(tree, 'simple log message', rev_id=b'a1',
1474
 
                       revprops={u'bugs': 'test://bug/id invalid_value'})
1475
 
 
1476
 
        logfile = self.make_utf8_encoded_stringio()
1477
 
        formatter = log.ShortLogFormatter(to_file=logfile)
1478
 
        log.show_log(tree.branch, formatter)
1479
 
 
1480
 
        lines = logfile.getvalue().splitlines()
1481
 
 
1482
 
        self.assertEqual(
1483
 
            lines[0], b'    1 Joe Foo\t2005-11-22')
1484
 
 
1485
 
        self.assertEqual(
1486
 
            lines[1],
1487
 
            b'brz: ERROR: breezy.bugtracker.InvalidBugStatus: Invalid '
1488
 
            b'bug status: \'invalid_value\'')
1489
 
 
1490
 
        self.assertEqual(lines[-2], b"      simple log message")
 
1443
        self.wt_commit(tree, 'simple log message', rev_id='a1',
 
1444
                       revprops={'bugs': 'test://bug/id invalid_value'})
 
1445
        self.assertFormatterResult("""\
 
1446
    1 Joe Foo\t2005-11-22
 
1447
      simple log message
 
1448
 
 
1449
""",
 
1450
            tree.branch, log.ShortLogFormatter)
1491
1451
 
1492
1452
    def test_bugs_handler_present(self):
1493
1453
        self.properties_handler_registry.get('bugs_properties_handler')
1498
1458
    def setUp(self):
1499
1459
        super(TestLogForAuthors, self).setUp()
1500
1460
        self.wt = self.make_standard_commit('nicky',
1501
 
                                            authors=['John Doe <jdoe@example.com>',
1502
 
                                                     'Jane Rey <jrey@example.com>'])
 
1461
            authors=['John Doe <jdoe@example.com>',
 
1462
                     'Jane Rey <jrey@example.com>'])
1503
1463
 
1504
1464
    def assertFormatterResult(self, formatter, who, result):
1505
1465
        formatter_kwargs = dict()
1507
1467
            author_list_handler = log.author_list_registry.get(who)
1508
1468
            formatter_kwargs['author_list_handler'] = author_list_handler
1509
1469
        TestCaseForLogFormatter.assertFormatterResult(self, result,
1510
 
                                                      self.wt.branch, formatter, formatter_kwargs=formatter_kwargs)
 
1470
            self.wt.branch, formatter, formatter_kwargs=formatter_kwargs)
1511
1471
 
1512
1472
    def test_line_default(self):
1513
 
        self.assertFormatterResult(log.LineLogFormatter, None, b"""\
 
1473
        self.assertFormatterResult(log.LineLogFormatter, None, """\
1514
1474
1: John Doe 2005-11-22 add a
1515
1475
""")
1516
1476
 
1517
1477
    def test_line_committer(self):
1518
 
        self.assertFormatterResult(log.LineLogFormatter, 'committer', b"""\
 
1478
        self.assertFormatterResult(log.LineLogFormatter, 'committer', """\
1519
1479
1: Lorem Ipsum 2005-11-22 add a
1520
1480
""")
1521
1481
 
1522
1482
    def test_line_first(self):
1523
 
        self.assertFormatterResult(log.LineLogFormatter, 'first', b"""\
 
1483
        self.assertFormatterResult(log.LineLogFormatter, 'first', """\
1524
1484
1: John Doe 2005-11-22 add a
1525
1485
""")
1526
1486
 
1527
1487
    def test_line_all(self):
1528
 
        self.assertFormatterResult(log.LineLogFormatter, 'all', b"""\
 
1488
        self.assertFormatterResult(log.LineLogFormatter, 'all', """\
1529
1489
1: John Doe, Jane Rey 2005-11-22 add a
1530
1490
""")
1531
1491
 
 
1492
 
1532
1493
    def test_short_default(self):
1533
 
        self.assertFormatterResult(log.ShortLogFormatter, None, b"""\
 
1494
        self.assertFormatterResult(log.ShortLogFormatter, None, """\
1534
1495
    1 John Doe\t2005-11-22
1535
1496
      add a
1536
1497
 
1537
1498
""")
1538
1499
 
1539
1500
    def test_short_committer(self):
1540
 
        self.assertFormatterResult(log.ShortLogFormatter, 'committer', b"""\
 
1501
        self.assertFormatterResult(log.ShortLogFormatter, 'committer', """\
1541
1502
    1 Lorem Ipsum\t2005-11-22
1542
1503
      add a
1543
1504
 
1544
1505
""")
1545
1506
 
1546
1507
    def test_short_first(self):
1547
 
        self.assertFormatterResult(log.ShortLogFormatter, 'first', b"""\
 
1508
        self.assertFormatterResult(log.ShortLogFormatter, 'first', """\
1548
1509
    1 John Doe\t2005-11-22
1549
1510
      add a
1550
1511
 
1551
1512
""")
1552
1513
 
1553
1514
    def test_short_all(self):
1554
 
        self.assertFormatterResult(log.ShortLogFormatter, 'all', b"""\
 
1515
        self.assertFormatterResult(log.ShortLogFormatter, 'all', """\
1555
1516
    1 John Doe, Jane Rey\t2005-11-22
1556
1517
      add a
1557
1518
 
1558
1519
""")
1559
1520
 
1560
1521
    def test_long_default(self):
1561
 
        self.assertFormatterResult(log.LongLogFormatter, None, b"""\
 
1522
        self.assertFormatterResult(log.LongLogFormatter, None, """\
1562
1523
------------------------------------------------------------
1563
1524
revno: 1
1564
1525
author: John Doe <jdoe@example.com>, Jane Rey <jrey@example.com>
1570
1531
""")
1571
1532
 
1572
1533
    def test_long_committer(self):
1573
 
        self.assertFormatterResult(log.LongLogFormatter, 'committer', b"""\
 
1534
        self.assertFormatterResult(log.LongLogFormatter, 'committer', """\
1574
1535
------------------------------------------------------------
1575
1536
revno: 1
1576
1537
committer: Lorem Ipsum <test@example.com>
1581
1542
""")
1582
1543
 
1583
1544
    def test_long_first(self):
1584
 
        self.assertFormatterResult(log.LongLogFormatter, 'first', b"""\
 
1545
        self.assertFormatterResult(log.LongLogFormatter, 'first', """\
1585
1546
------------------------------------------------------------
1586
1547
revno: 1
1587
1548
author: John Doe <jdoe@example.com>
1593
1554
""")
1594
1555
 
1595
1556
    def test_long_all(self):
1596
 
        self.assertFormatterResult(log.LongLogFormatter, 'all', b"""\
 
1557
        self.assertFormatterResult(log.LongLogFormatter, 'all', """\
1597
1558
------------------------------------------------------------
1598
1559
revno: 1
1599
1560
author: John Doe <jdoe@example.com>, Jane Rey <jrey@example.com>
1605
1566
""")
1606
1567
 
1607
1568
    def test_gnu_changelog_default(self):
1608
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, None, b"""\
 
1569
        self.assertFormatterResult(log.GnuChangelogLogFormatter, None, """\
1609
1570
2005-11-22  John Doe  <jdoe@example.com>
1610
1571
 
1611
1572
\tadd a
1613
1574
""")
1614
1575
 
1615
1576
    def test_gnu_changelog_committer(self):
1616
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'committer', b"""\
 
1577
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'committer', """\
1617
1578
2005-11-22  Lorem Ipsum  <test@example.com>
1618
1579
 
1619
1580
\tadd a
1621
1582
""")
1622
1583
 
1623
1584
    def test_gnu_changelog_first(self):
1624
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'first', b"""\
 
1585
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'first', """\
1625
1586
2005-11-22  John Doe  <jdoe@example.com>
1626
1587
 
1627
1588
\tadd a
1629
1590
""")
1630
1591
 
1631
1592
    def test_gnu_changelog_all(self):
1632
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'all', b"""\
 
1593
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'all', """\
1633
1594
2005-11-22  John Doe  <jdoe@example.com>, Jane Rey  <jrey@example.com>
1634
1595
 
1635
1596
\tadd a
1660
1621
        # 3
1661
1622
        builder.start_series()
1662
1623
        builder.build_snapshot(None, [
1663
 
            ('add', ('', b'TREE_ROOT', 'directory', '')), ],
1664
 
            revision_id=b'1')
1665
 
        builder.build_snapshot([b'1'], [], revision_id=b'1.1.1')
1666
 
        builder.build_snapshot([b'1'], [], revision_id=b'2')
1667
 
        builder.build_snapshot([b'1.1.1'], [], revision_id=b'1.2.1')
1668
 
        builder.build_snapshot([b'1.1.1', b'1.2.1'], [], revision_id=b'1.1.2')
1669
 
        builder.build_snapshot([b'2', b'1.1.2'], [], revision_id=b'3')
 
1624
            ('add', ('', 'TREE_ROOT', 'directory', '')),],
 
1625
            revision_id='1')
 
1626
        builder.build_snapshot(['1'], [], revision_id='1.1.1')
 
1627
        builder.build_snapshot(['1'], [], revision_id='2')
 
1628
        builder.build_snapshot(['1.1.1'], [], revision_id='1.2.1')
 
1629
        builder.build_snapshot(['1.1.1', '1.2.1'], [], revision_id='1.1.2')
 
1630
        builder.build_snapshot(['2', '1.1.2'], [], revision_id='3')
1670
1631
        builder.finish_series()
1671
1632
        br = builder.get_branch()
1672
1633
        br.lock_read()
1687
1648
 
1688
1649
    def test_merge_sorted_exclude_ancestry(self):
1689
1650
        b = self.make_branch_with_alternate_ancestries()
1690
 
        self.assertLogRevnos([b'3', b'1.1.2', b'1.2.1', b'1.1.1', b'2', b'1'],
1691
 
                             b, b'1', b'3', exclude_common_ancestry=False)
 
1651
        self.assertLogRevnos(['3', '1.1.2', '1.2.1', '1.1.1', '2', '1'],
 
1652
                             b, '1', '3', exclude_common_ancestry=False)
1692
1653
        # '2' is part of the '3' ancestry but not part of '1.1.1' ancestry so
1693
1654
        # it should be mentioned even if merge_sort order will make it appear
1694
1655
        # after 1.1.1
1695
 
        self.assertLogRevnos([b'3', b'1.1.2', b'1.2.1', b'2'],
1696
 
                             b, b'1.1.1', b'3', exclude_common_ancestry=True)
 
1656
        self.assertLogRevnos(['3', '1.1.2', '1.2.1', '2'],
 
1657
                             b, '1.1.1', '3', exclude_common_ancestry=True)
1697
1658
 
1698
1659
    def test_merge_sorted_simple_revnos_exclude_ancestry(self):
1699
1660
        b = self.make_branch_with_alternate_ancestries()
1700
 
        self.assertLogRevnos([b'3', b'2'],
1701
 
                             b, b'1', b'3', exclude_common_ancestry=True,
 
1661
        self.assertLogRevnos(['3', '2'],
 
1662
                             b, '1', '3', exclude_common_ancestry=True,
1702
1663
                             generate_merge_revisions=False)
1703
 
        self.assertLogRevnos([b'3', b'1.1.2', b'1.2.1', b'1.1.1', b'2'],
1704
 
                             b, b'1', b'3', exclude_common_ancestry=True,
 
1664
        self.assertLogRevnos(['3', '1.1.2', '1.2.1', '1.1.1', '2'],
 
1665
                             b, '1', '3', exclude_common_ancestry=True,
1705
1666
                             generate_merge_revisions=True)
1706
1667
 
1707
1668
 
1720
1681
            def __init__(self, *args, **kwargs):
1721
1682
                super(CustomLogFormatter, self).__init__(*args, **kwargs)
1722
1683
                self.revisions = []
1723
 
 
1724
1684
            def get_levels(self):
1725
1685
                # log formatter supports all levels:
1726
1686
                return 0
1727
 
 
1728
1687
            def log_revision(self, revision):
1729
1688
                self.revisions.append(revision)
1730
1689
 
1744
1703
        log.Logger(b, request).show(log_formatter)
1745
1704
        # should now only have 2 revisions:
1746
1705
        self.assertEqual(len(log_formatter.revisions), 2)
 
1706