← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_log.py

  • Committer: Martin Pool
  • Date: 2010-01-15 04:17:57 UTC
  • mto: This revision was merged to the branch mainline in revision 5019.
  • Revision ID: mbp@sourcefrog.net-20100115041757-cd8pu9o5a511jc8q
Rip out most remaining uses of DummyProgressBar

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_log.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
18
18
from cStringIO import StringIO
19
19
 
20
20
from bzrlib import (
21
 
    branchbuilder,
22
21
    errors,
23
22
    log,
24
23
    registry,
25
24
    revision,
26
25
    revisionspec,
27
 
    symbol_versioning,
28
26
    tests,
29
27
    )
30
28
 
31
29
 
32
 
class TestLogMixin(object):
33
 
 
34
 
    def wt_commit(self, wt, message, **kwargs):
35
 
        """Use some mostly fixed values for commits to simplify tests.
36
 
 
37
 
        Tests can use this function to get some commit attributes. The time
38
 
        stamp is incremented at each commit.
39
 
        """
40
 
        if getattr(self, 'timestamp', None) is None:
41
 
            self.timestamp = 1132617600 # Mon 2005-11-22 00:00:00 +0000
42
 
        else:
43
 
            self.timestamp += 1 # 1 second between each commit
44
 
        kwargs.setdefault('timestamp', self.timestamp)
45
 
        kwargs.setdefault('timezone', 0) # UTC
46
 
        kwargs.setdefault('committer', 'Joe Foo <joe@foo.com>')
47
 
 
48
 
        return wt.commit(message, **kwargs)
49
 
 
50
 
 
51
 
class TestCaseForLogFormatter(tests.TestCaseWithTransport, TestLogMixin):
 
30
class TestCaseForLogFormatter(tests.TestCaseWithTransport):
52
31
 
53
32
    def setUp(self):
54
33
        super(TestCaseForLogFormatter, self).setUp()
62
41
        self.addCleanup(restore)
63
42
 
64
43
    def assertFormatterResult(self, result, branch, formatter_class,
65
 
                              formatter_kwargs=None, show_log_kwargs=None):
 
44
                              formatter_kwargs=None, show_log_kwargs=None,
 
45
                              normalize=False):
66
46
        logfile = self.make_utf8_encoded_stringio()
67
47
        if formatter_kwargs is None:
68
48
            formatter_kwargs = {}
70
50
        if show_log_kwargs is None:
71
51
            show_log_kwargs = {}
72
52
        log.show_log(branch, formatter, **show_log_kwargs)
73
 
        self.assertEqualDiff(result, logfile.getvalue())
 
53
        log_content = logfile.getvalue()
 
54
        if normalize:
 
55
            log_content = normalize_log(log_content)
 
56
        self.assertEqualDiff(result, log_content)
74
57
 
75
58
    def make_standard_commit(self, branch_nick, **kwargs):
76
59
        wt = self.make_branch_and_tree('.')
79
62
        self.build_tree(['a'])
80
63
        wt.add(['a'])
81
64
        wt.branch.nick = branch_nick
 
65
        kwargs = dict(kwargs)
 
66
        kwargs.setdefault('message', 'add a')
 
67
        kwargs.setdefault('timestamp', 1132711707)
 
68
        kwargs.setdefault('timezone', 36000)
82
69
        kwargs.setdefault('committer', 'Lorem Ipsum <test@example.com>')
83
70
        kwargs.setdefault('authors', ['John Doe <jdoe@example.com>'])
84
 
        self.wt_commit(wt, 'add a', **kwargs)
 
71
        wt.commit(**kwargs)
85
72
        return wt
86
73
 
87
 
    def make_commits_with_trailing_newlines(self, wt):
88
 
        """Helper method for LogFormatter tests"""
89
 
        b = wt.branch
90
 
        b.nick = 'test'
91
 
        self.build_tree_contents([('a', 'hello moto\n')])
92
 
        self.wt_commit(wt, 'simple log message', rev_id='a1')
93
 
        self.build_tree_contents([('b', 'goodbye\n')])
94
 
        wt.add('b')
95
 
        self.wt_commit(wt, 'multiline\nlog\nmessage\n', rev_id='a2')
96
 
 
97
 
        self.build_tree_contents([('c', 'just another manic monday\n')])
98
 
        wt.add('c')
99
 
        self.wt_commit(wt, 'single line with trailing newline\n', rev_id='a3')
100
 
        return b
101
 
 
102
74
    def _prepare_tree_with_merges(self, with_tags=False):
103
75
        wt = self.make_branch_and_memory_tree('.')
104
76
        wt.lock_write()
105
77
        self.addCleanup(wt.unlock)
106
78
        wt.add('')
107
 
        self.wt_commit(wt, 'rev-1', rev_id='rev-1')
108
 
        self.wt_commit(wt, 'rev-merged', rev_id='rev-2a')
 
79
        wt.commit('rev-1', rev_id='rev-1',
 
80
                  timestamp=1132586655, timezone=36000,
 
81
                  committer='Joe Foo <joe@foo.com>')
 
82
        wt.commit('rev-merged', rev_id='rev-2a',
 
83
                  timestamp=1132586700, timezone=36000,
 
84
                  committer='Joe Foo <joe@foo.com>')
109
85
        wt.set_parent_ids(['rev-1', 'rev-2a'])
110
86
        wt.branch.set_last_revision_info(1, 'rev-1')
111
 
        self.wt_commit(wt, 'rev-2', rev_id='rev-2b')
 
87
        wt.commit('rev-2', rev_id='rev-2b',
 
88
                  timestamp=1132586800, timezone=36000,
 
89
                  committer='Joe Foo <joe@foo.com>')
112
90
        if with_tags:
113
91
            branch = wt.branch
114
92
            branch.tags.set_tag('v0.2', 'rev-2b')
115
 
            self.wt_commit(wt, 'rev-3', rev_id='rev-3')
 
93
            wt.commit('rev-3', rev_id='rev-3',
 
94
                      timestamp=1132586900, timezone=36000,
 
95
                      committer='Jane Foo <jane@foo.com>')
116
96
            branch.tags.set_tag('v1.0rc1', 'rev-3')
117
97
            branch.tags.set_tag('v1.0', 'rev-3')
118
98
        return wt
119
99
 
 
100
        
 
101
 
120
102
 
121
103
class LogCatcher(log.LogFormatter):
122
104
    """Pull log messages into a list rather than displaying them.
126
108
    being dependent on the formatting.
127
109
    """
128
110
 
129
 
    supports_merge_revisions = True
130
111
    supports_delta = True
131
 
    supports_diff = True
132
 
    preferred_levels = 0
133
112
 
134
 
    def __init__(self, *args, **kwargs):
135
 
        kwargs.update(dict(to_file=None))
136
 
        super(LogCatcher, self).__init__(*args, **kwargs)
 
113
    def __init__(self):
 
114
        super(LogCatcher, self).__init__(to_file=None)
137
115
        self.revisions = []
138
116
 
139
117
    def log_revision(self, revision):
282
260
        self.checkDelta(logentry.delta, added=['file1', 'file2'])
283
261
 
284
262
 
 
263
def make_commits_with_trailing_newlines(wt):
 
264
    """Helper method for LogFormatter tests"""
 
265
    b = wt.branch
 
266
    b.nick='test'
 
267
    open('a', 'wb').write('hello moto\n')
 
268
    wt.add('a')
 
269
    wt.commit('simple log message', rev_id='a1',
 
270
              timestamp=1132586655.459960938, timezone=-6*3600,
 
271
              committer='Joe Foo <joe@foo.com>')
 
272
    open('b', 'wb').write('goodbye\n')
 
273
    wt.add('b')
 
274
    wt.commit('multiline\nlog\nmessage\n', rev_id='a2',
 
275
              timestamp=1132586842.411175966, timezone=-6*3600,
 
276
              committer='Joe Foo <joe@foo.com>',
 
277
              authors=['Joe Bar <joe@bar.com>'])
 
278
 
 
279
    open('c', 'wb').write('just another manic monday\n')
 
280
    wt.add('c')
 
281
    wt.commit('single line with trailing newline\n', rev_id='a3',
 
282
              timestamp=1132587176.835228920, timezone=-6*3600,
 
283
              committer = 'Joe Foo <joe@foo.com>')
 
284
    return b
 
285
 
 
286
 
 
287
def normalize_log(log):
 
288
    """Replaces the variable lines of logs with fixed lines"""
 
289
    author = 'author: Dolor Sit <test@example.com>'
 
290
    committer = 'committer: Lorem Ipsum <test@example.com>'
 
291
    lines = log.splitlines(True)
 
292
    for idx,line in enumerate(lines):
 
293
        stripped_line = line.lstrip()
 
294
        indent = ' ' * (len(line) - len(stripped_line))
 
295
        if stripped_line.startswith('author:'):
 
296
            lines[idx] = indent + author + '\n'
 
297
        elif stripped_line.startswith('committer:'):
 
298
            lines[idx] = indent + committer + '\n'
 
299
        elif stripped_line.startswith('timestamp:'):
 
300
            lines[idx] = indent + 'timestamp: Just now\n'
 
301
    return ''.join(lines)
 
302
 
 
303
 
285
304
class TestShortLogFormatter(TestCaseForLogFormatter):
286
305
 
287
306
    def test_trailing_newlines(self):
288
307
        wt = self.make_branch_and_tree('.')
289
 
        b = self.make_commits_with_trailing_newlines(wt)
 
308
        b = make_commits_with_trailing_newlines(wt)
290
309
        self.assertFormatterResult("""\
291
 
    3 Joe Foo\t2005-11-22
 
310
    3 Joe Foo\t2005-11-21
292
311
      single line with trailing newline
293
312
 
294
 
    2 Joe Foo\t2005-11-22
 
313
    2 Joe Bar\t2005-11-21
295
314
      multiline
296
315
      log
297
316
      message
298
317
 
299
 
    1 Joe Foo\t2005-11-22
 
318
    1 Joe Foo\t2005-11-21
300
319
      simple log message
301
320
 
302
321
""",
329
348
            formatter_kwargs=dict(show_advice=True))
330
349
 
331
350
    def test_short_log_with_merges_and_range(self):
332
 
        wt = self._prepare_tree_with_merges()
333
 
        self.wt_commit(wt, 'rev-3a', rev_id='rev-3a')
 
351
        wt = self.make_branch_and_memory_tree('.')
 
352
        wt.lock_write()
 
353
        self.addCleanup(wt.unlock)
 
354
        wt.add('')
 
355
        wt.commit('rev-1', rev_id='rev-1',
 
356
                  timestamp=1132586655, timezone=36000,
 
357
                  committer='Joe Foo <joe@foo.com>')
 
358
        wt.commit('rev-merged', rev_id='rev-2a',
 
359
                  timestamp=1132586700, timezone=36000,
 
360
                  committer='Joe Foo <joe@foo.com>')
 
361
        wt.branch.set_last_revision_info(1, 'rev-1')
 
362
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
363
        wt.commit('rev-2b', rev_id='rev-2b',
 
364
                  timestamp=1132586800, timezone=36000,
 
365
                  committer='Joe Foo <joe@foo.com>')
 
366
        wt.commit('rev-3a', rev_id='rev-3a',
 
367
                  timestamp=1132586800, timezone=36000,
 
368
                  committer='Joe Foo <joe@foo.com>')
334
369
        wt.branch.set_last_revision_info(2, 'rev-2b')
335
370
        wt.set_parent_ids(['rev-2b', 'rev-3a'])
336
 
        self.wt_commit(wt, 'rev-3b', rev_id='rev-3b')
 
371
        wt.commit('rev-3b', rev_id='rev-3b',
 
372
                  timestamp=1132586800, timezone=36000,
 
373
                  committer='Joe Foo <joe@foo.com>')
337
374
        self.assertFormatterResult("""\
338
375
    3 Joe Foo\t2005-11-22 [merge]
339
376
      rev-3b
340
377
 
341
378
    2 Joe Foo\t2005-11-22 [merge]
342
 
      rev-2
 
379
      rev-2b
343
380
 
344
381
""",
345
382
            wt.branch, log.ShortLogFormatter,
348
385
    def test_short_log_with_tags(self):
349
386
        wt = self._prepare_tree_with_merges(with_tags=True)
350
387
        self.assertFormatterResult("""\
351
 
    3 Joe Foo\t2005-11-22 {v1.0, v1.0rc1}
 
388
    3 Jane Foo\t2005-11-22 {v1.0, v1.0rc1}
352
389
      rev-3
353
390
 
354
391
    2 Joe Foo\t2005-11-22 {v0.2} [merge]
361
398
            wt.branch, log.ShortLogFormatter)
362
399
 
363
400
    def test_short_log_single_merge_revision(self):
364
 
        wt = self._prepare_tree_with_merges()
 
401
        wt = self.make_branch_and_memory_tree('.')
 
402
        wt.lock_write()
 
403
        self.addCleanup(wt.unlock)
 
404
        wt.add('')
 
405
        wt.commit('rev-1', rev_id='rev-1',
 
406
                  timestamp=1132586655, timezone=36000,
 
407
                  committer='Joe Foo <joe@foo.com>')
 
408
        wt.commit('rev-merged', rev_id='rev-2a',
 
409
                  timestamp=1132586700, timezone=36000,
 
410
                  committer='Joe Foo <joe@foo.com>')
 
411
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
412
        wt.branch.set_last_revision_info(1, 'rev-1')
 
413
        wt.commit('rev-2', rev_id='rev-2b',
 
414
                  timestamp=1132586800, timezone=36000,
 
415
                  committer='Joe Foo <joe@foo.com>')
365
416
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
366
417
        rev = revspec.in_history(wt.branch)
367
418
        self.assertFormatterResult("""\
372
423
            wt.branch, log.ShortLogFormatter,
373
424
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
374
425
 
375
 
    def test_show_ids(self):
376
 
        wt = self.make_branch_and_tree('parent')
377
 
        self.build_tree(['parent/f1', 'parent/f2'])
378
 
        wt.add(['f1','f2'])
379
 
        self.wt_commit(wt, 'first post', rev_id='a')
380
 
        child_wt = wt.bzrdir.sprout('child').open_workingtree()
381
 
        self.wt_commit(child_wt, 'branch 1 changes', rev_id='b')
382
 
        wt.merge_from_branch(child_wt.branch)
383
 
        self.wt_commit(wt, 'merge branch 1', rev_id='c')
384
 
        self.assertFormatterResult("""\
385
 
    2 Joe Foo\t2005-11-22 [merge]
386
 
      revision-id:c
387
 
      merge branch 1
388
 
 
389
 
          1.1.1 Joe Foo\t2005-11-22
390
 
                revision-id:b
391
 
                branch 1 changes
392
 
 
393
 
    1 Joe Foo\t2005-11-22
394
 
      revision-id:a
395
 
      first post
396
 
 
397
 
""",
398
 
            wt.branch, log.ShortLogFormatter,
399
 
            formatter_kwargs=dict(levels=0,show_ids=True))
400
 
 
401
426
 
402
427
class TestShortLogFormatterWithMergeRevisions(TestCaseForLogFormatter):
403
428
 
404
429
    def test_short_merge_revs_log_with_merges(self):
405
 
        wt = self._prepare_tree_with_merges()
 
430
        wt = self.make_branch_and_memory_tree('.')
 
431
        wt.lock_write()
 
432
        self.addCleanup(wt.unlock)
 
433
        wt.add('')
 
434
        wt.commit('rev-1', rev_id='rev-1',
 
435
                  timestamp=1132586655, timezone=36000,
 
436
                  committer='Joe Foo <joe@foo.com>')
 
437
        wt.commit('rev-merged', rev_id='rev-2a',
 
438
                  timestamp=1132586700, timezone=36000,
 
439
                  committer='Joe Foo <joe@foo.com>')
 
440
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
441
        wt.branch.set_last_revision_info(1, 'rev-1')
 
442
        wt.commit('rev-2', rev_id='rev-2b',
 
443
                  timestamp=1132586800, timezone=36000,
 
444
                  committer='Joe Foo <joe@foo.com>')
406
445
        # Note that the 1.1.1 indenting is in fact correct given that
407
446
        # the revision numbers are right justified within 5 characters
408
447
        # for mainline revnos and 9 characters for dotted revnos.
421
460
            formatter_kwargs=dict(levels=0))
422
461
 
423
462
    def test_short_merge_revs_log_single_merge_revision(self):
424
 
        wt = self._prepare_tree_with_merges()
 
463
        wt = self.make_branch_and_memory_tree('.')
 
464
        wt.lock_write()
 
465
        self.addCleanup(wt.unlock)
 
466
        wt.add('')
 
467
        wt.commit('rev-1', rev_id='rev-1',
 
468
                  timestamp=1132586655, timezone=36000,
 
469
                  committer='Joe Foo <joe@foo.com>')
 
470
        wt.commit('rev-merged', rev_id='rev-2a',
 
471
                  timestamp=1132586700, timezone=36000,
 
472
                  committer='Joe Foo <joe@foo.com>')
 
473
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
474
        wt.branch.set_last_revision_info(1, 'rev-1')
 
475
        wt.commit('rev-2', rev_id='rev-2b',
 
476
                  timestamp=1132586800, timezone=36000,
 
477
                  committer='Joe Foo <joe@foo.com>')
425
478
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
426
479
        rev = revspec.in_history(wt.branch)
427
480
        self.assertFormatterResult("""\
447
500
revno: 1
448
501
committer: Lorem Ipsum <test@example.com>
449
502
branch nick: test_verbose_log
450
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
503
timestamp: Wed 2005-11-23 12:08:27 +1000
451
504
message:
452
505
  add a
453
506
added:
458
511
 
459
512
    def test_merges_are_indented_by_level(self):
460
513
        wt = self.make_branch_and_tree('parent')
461
 
        self.wt_commit(wt, 'first post')
462
 
        child_wt = wt.bzrdir.sprout('child').open_workingtree()
463
 
        self.wt_commit(child_wt, 'branch 1')
464
 
        smallerchild_wt = wt.bzrdir.sprout('smallerchild').open_workingtree()
465
 
        self.wt_commit(smallerchild_wt, 'branch 2')
466
 
        child_wt.merge_from_branch(smallerchild_wt.branch)
467
 
        self.wt_commit(child_wt, 'merge branch 2')
468
 
        wt.merge_from_branch(child_wt.branch)
469
 
        self.wt_commit(wt, 'merge branch 1')
 
514
        wt.commit('first post')
 
515
        self.run_bzr('branch parent child')
 
516
        self.run_bzr(['commit', '-m', 'branch 1', '--unchanged', 'child'])
 
517
        self.run_bzr('branch child smallerchild')
 
518
        self.run_bzr(['commit', '-m', 'branch 2', '--unchanged',
 
519
            'smallerchild'])
 
520
        os.chdir('child')
 
521
        self.run_bzr('merge ../smallerchild')
 
522
        self.run_bzr(['commit', '-m', 'merge branch 2'])
 
523
        os.chdir('../parent')
 
524
        self.run_bzr('merge ../child')
 
525
        wt.commit('merge branch 1')
470
526
        self.assertFormatterResult("""\
471
527
------------------------------------------------------------
472
528
revno: 2 [merge]
473
 
committer: Joe Foo <joe@foo.com>
 
529
committer: Lorem Ipsum <test@example.com>
474
530
branch nick: parent
475
 
timestamp: Tue 2005-11-22 00:00:04 +0000
 
531
timestamp: Just now
476
532
message:
477
533
  merge branch 1
478
534
    ------------------------------------------------------------
479
535
    revno: 1.1.2 [merge]
480
 
    committer: Joe Foo <joe@foo.com>
 
536
    committer: Lorem Ipsum <test@example.com>
481
537
    branch nick: child
482
 
    timestamp: Tue 2005-11-22 00:00:03 +0000
 
538
    timestamp: Just now
483
539
    message:
484
540
      merge branch 2
485
541
        ------------------------------------------------------------
486
542
        revno: 1.2.1
487
 
        committer: Joe Foo <joe@foo.com>
 
543
        committer: Lorem Ipsum <test@example.com>
488
544
        branch nick: smallerchild
489
 
        timestamp: Tue 2005-11-22 00:00:02 +0000
 
545
        timestamp: Just now
490
546
        message:
491
547
          branch 2
492
548
    ------------------------------------------------------------
493
549
    revno: 1.1.1
494
 
    committer: Joe Foo <joe@foo.com>
 
550
    committer: Lorem Ipsum <test@example.com>
495
551
    branch nick: child
496
 
    timestamp: Tue 2005-11-22 00:00:01 +0000
 
552
    timestamp: Just now
497
553
    message:
498
554
      branch 1
499
555
------------------------------------------------------------
500
556
revno: 1
501
 
committer: Joe Foo <joe@foo.com>
 
557
committer: Lorem Ipsum <test@example.com>
502
558
branch nick: parent
503
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
559
timestamp: Just now
504
560
message:
505
561
  first post
506
562
""",
507
563
            wt.branch, log.LongLogFormatter,
508
564
            formatter_kwargs=dict(levels=0),
509
 
            show_log_kwargs=dict(verbose=True))
 
565
            show_log_kwargs=dict(verbose=True),
 
566
            normalize=True)
510
567
 
511
568
    def test_verbose_merge_revisions_contain_deltas(self):
512
569
        wt = self.make_branch_and_tree('parent')
513
570
        self.build_tree(['parent/f1', 'parent/f2'])
514
571
        wt.add(['f1','f2'])
515
 
        self.wt_commit(wt, 'first post')
516
 
        child_wt = wt.bzrdir.sprout('child').open_workingtree()
 
572
        wt.commit('first post')
 
573
        self.run_bzr('branch parent child')
517
574
        os.unlink('child/f1')
518
 
        self.build_tree_contents([('child/f2', 'hello\n')])
519
 
        self.wt_commit(child_wt, 'removed f1 and modified f2')
520
 
        wt.merge_from_branch(child_wt.branch)
521
 
        self.wt_commit(wt, 'merge branch 1')
 
575
        file('child/f2', 'wb').write('hello\n')
 
576
        self.run_bzr(['commit', '-m', 'removed f1 and modified f2',
 
577
            'child'])
 
578
        os.chdir('parent')
 
579
        self.run_bzr('merge ../child')
 
580
        wt.commit('merge branch 1')
522
581
        self.assertFormatterResult("""\
523
582
------------------------------------------------------------
524
583
revno: 2 [merge]
525
 
committer: Joe Foo <joe@foo.com>
 
584
committer: Lorem Ipsum <test@example.com>
526
585
branch nick: parent
527
 
timestamp: Tue 2005-11-22 00:00:02 +0000
 
586
timestamp: Just now
528
587
message:
529
588
  merge branch 1
530
589
removed:
533
592
  f2
534
593
    ------------------------------------------------------------
535
594
    revno: 1.1.1
536
 
    committer: Joe Foo <joe@foo.com>
 
595
    committer: Lorem Ipsum <test@example.com>
537
596
    branch nick: child
538
 
    timestamp: Tue 2005-11-22 00:00:01 +0000
 
597
    timestamp: Just now
539
598
    message:
540
599
      removed f1 and modified f2
541
600
    removed:
544
603
      f2
545
604
------------------------------------------------------------
546
605
revno: 1
547
 
committer: Joe Foo <joe@foo.com>
 
606
committer: Lorem Ipsum <test@example.com>
548
607
branch nick: parent
549
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
608
timestamp: Just now
550
609
message:
551
610
  first post
552
611
added:
555
614
""",
556
615
            wt.branch, log.LongLogFormatter,
557
616
            formatter_kwargs=dict(levels=0),
558
 
            show_log_kwargs=dict(verbose=True))
 
617
            show_log_kwargs=dict(verbose=True),
 
618
            normalize=True)
559
619
 
560
620
    def test_trailing_newlines(self):
561
621
        wt = self.make_branch_and_tree('.')
562
 
        b = self.make_commits_with_trailing_newlines(wt)
 
622
        b = make_commits_with_trailing_newlines(wt)
563
623
        self.assertFormatterResult("""\
564
624
------------------------------------------------------------
565
625
revno: 3
566
626
committer: Joe Foo <joe@foo.com>
567
627
branch nick: test
568
 
timestamp: Tue 2005-11-22 00:00:02 +0000
 
628
timestamp: Mon 2005-11-21 09:32:56 -0600
569
629
message:
570
630
  single line with trailing newline
571
631
------------------------------------------------------------
572
632
revno: 2
 
633
author: Joe Bar <joe@bar.com>
573
634
committer: Joe Foo <joe@foo.com>
574
635
branch nick: test
575
 
timestamp: Tue 2005-11-22 00:00:01 +0000
 
636
timestamp: Mon 2005-11-21 09:27:22 -0600
576
637
message:
577
638
  multiline
578
639
  log
581
642
revno: 1
582
643
committer: Joe Foo <joe@foo.com>
583
644
branch nick: test
584
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
645
timestamp: Mon 2005-11-21 09:24:15 -0600
585
646
message:
586
647
  simple log message
587
648
""",
600
661
author: John Doe <jdoe@example.com>, Jane Rey <jrey@example.com>
601
662
committer: Lorem Ipsum <test@example.com>
602
663
branch nick: test_author_log
603
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
664
timestamp: Wed 2005-11-23 12:08:27 +1000
604
665
message:
605
666
  add a
606
667
""",
625
686
author: John Doe <jdoe@example.com>
626
687
committer: Lorem Ipsum <test@example.com>
627
688
branch nick: test_properties_in_log
628
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
689
timestamp: Wed 2005-11-23 12:08:27 +1000
629
690
message:
630
691
  add a
631
692
""",
643
704
            'trivial_custom_prop_handler',
644
705
            trivial_custom_prop_handler)
645
706
        self.assertFormatterResult("""\
646
 
    1 John Doe\t2005-11-22
 
707
    1 John Doe\t2005-11-23
647
708
      test_prop: test_value
648
709
      add a
649
710
 
686
747
        self.assertEqualDiff('''custom_prop_name: test_value\n''',
687
748
                             sio.getvalue())
688
749
 
689
 
    def test_show_ids(self):
690
 
        wt = self.make_branch_and_tree('parent')
691
 
        self.build_tree(['parent/f1', 'parent/f2'])
692
 
        wt.add(['f1','f2'])
693
 
        self.wt_commit(wt, 'first post', rev_id='a')
694
 
        child_wt = wt.bzrdir.sprout('child').open_workingtree()
695
 
        self.wt_commit(child_wt, 'branch 1 changes', rev_id='b')
696
 
        wt.merge_from_branch(child_wt.branch)
697
 
        self.wt_commit(wt, 'merge branch 1', rev_id='c')
698
 
        self.assertFormatterResult("""\
699
 
------------------------------------------------------------
700
 
revno: 2 [merge]
701
 
revision-id: c
702
 
parent: a
703
 
parent: b
704
 
committer: Joe Foo <joe@foo.com>
705
 
branch nick: parent
706
 
timestamp: Tue 2005-11-22 00:00:02 +0000
707
 
message:
708
 
  merge branch 1
709
 
    ------------------------------------------------------------
710
 
    revno: 1.1.1
711
 
    revision-id: b
712
 
    parent: a
713
 
    committer: Joe Foo <joe@foo.com>
714
 
    branch nick: child
715
 
    timestamp: Tue 2005-11-22 00:00:01 +0000
716
 
    message:
717
 
      branch 1 changes
718
 
------------------------------------------------------------
719
 
revno: 1
720
 
revision-id: a
721
 
committer: Joe Foo <joe@foo.com>
722
 
branch nick: parent
723
 
timestamp: Tue 2005-11-22 00:00:00 +0000
724
 
message:
725
 
  first post
726
 
""",
727
 
            wt.branch, log.LongLogFormatter,
728
 
            formatter_kwargs=dict(levels=0,show_ids=True))
729
 
 
730
750
 
731
751
class TestLongLogFormatterWithoutMergeRevisions(TestCaseForLogFormatter):
732
752
 
741
761
revno: 1
742
762
committer: Lorem Ipsum <test@example.com>
743
763
branch nick: test_long_verbose_log
744
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
764
timestamp: Wed 2005-11-23 12:08:27 +1000
745
765
message:
746
766
  add a
747
767
added:
755
775
        wt = self.make_branch_and_tree('parent')
756
776
        self.build_tree(['parent/f1', 'parent/f2'])
757
777
        wt.add(['f1','f2'])
758
 
        self.wt_commit(wt, 'first post')
 
778
        wt.commit('first post')
759
779
        child_wt = wt.bzrdir.sprout('child').open_workingtree()
760
780
        os.unlink('child/f1')
761
781
        self.build_tree_contents([('child/f2', 'hello\n')])
762
 
        self.wt_commit(child_wt, 'removed f1 and modified f2')
 
782
        child_wt.commit('removed f1 and modified f2')
763
783
        wt.merge_from_branch(child_wt.branch)
764
 
        self.wt_commit(wt, 'merge branch 1')
 
784
        wt.commit('merge branch 1')
765
785
        self.assertFormatterResult("""\
766
786
------------------------------------------------------------
767
787
revno: 2 [merge]
768
 
committer: Joe Foo <joe@foo.com>
 
788
committer: Lorem Ipsum <test@example.com>
769
789
branch nick: parent
770
 
timestamp: Tue 2005-11-22 00:00:02 +0000
 
790
timestamp: Just now
771
791
message:
772
792
  merge branch 1
773
793
removed:
776
796
  f2
777
797
------------------------------------------------------------
778
798
revno: 1
779
 
committer: Joe Foo <joe@foo.com>
 
799
committer: Lorem Ipsum <test@example.com>
780
800
branch nick: parent
781
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
801
timestamp: Just now
782
802
message:
783
803
  first post
784
804
added:
787
807
""",
788
808
            wt.branch, log.LongLogFormatter,
789
809
            formatter_kwargs=dict(levels=1),
790
 
            show_log_kwargs=dict(verbose=True))
 
810
            show_log_kwargs=dict(verbose=True),
 
811
            normalize=True)
791
812
 
792
813
    def test_long_trailing_newlines(self):
793
814
        wt = self.make_branch_and_tree('.')
794
 
        b = self.make_commits_with_trailing_newlines(wt)
 
815
        b = make_commits_with_trailing_newlines(wt)
795
816
        self.assertFormatterResult("""\
796
817
------------------------------------------------------------
797
818
revno: 3
798
819
committer: Joe Foo <joe@foo.com>
799
820
branch nick: test
800
 
timestamp: Tue 2005-11-22 00:00:02 +0000
 
821
timestamp: Mon 2005-11-21 09:32:56 -0600
801
822
message:
802
823
  single line with trailing newline
803
824
------------------------------------------------------------
804
825
revno: 2
 
826
author: Joe Bar <joe@bar.com>
805
827
committer: Joe Foo <joe@foo.com>
806
828
branch nick: test
807
 
timestamp: Tue 2005-11-22 00:00:01 +0000
 
829
timestamp: Mon 2005-11-21 09:27:22 -0600
808
830
message:
809
831
  multiline
810
832
  log
813
835
revno: 1
814
836
committer: Joe Foo <joe@foo.com>
815
837
branch nick: test
816
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
838
timestamp: Mon 2005-11-21 09:24:15 -0600
817
839
message:
818
840
  simple log message
819
841
""",
831
853
author: John Doe <jdoe@example.com>
832
854
committer: Lorem Ipsum <test@example.com>
833
855
branch nick: test_author_log
834
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
856
timestamp: Wed 2005-11-23 12:08:27 +1000
835
857
message:
836
858
  add a
837
859
""",
856
878
author: John Doe <jdoe@example.com>
857
879
committer: Lorem Ipsum <test@example.com>
858
880
branch nick: test_properties_in_log
859
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
881
timestamp: Wed 2005-11-23 12:08:27 +1000
860
882
message:
861
883
  add a
862
884
""",
875
897
                committer='Line-Log-Formatter Tester <test@line.log>',
876
898
                authors=[])
877
899
        self.assertFormatterResult("""\
878
 
1: Line-Log-Formatte... 2005-11-22 add a
 
900
1: Line-Log-Formatte... 2005-11-23 add a
879
901
""",
880
902
            wt.branch, log.LineLogFormatter)
881
903
 
882
904
    def test_trailing_newlines(self):
883
905
        wt = self.make_branch_and_tree('.')
884
 
        b = self.make_commits_with_trailing_newlines(wt)
 
906
        b = make_commits_with_trailing_newlines(wt)
885
907
        self.assertFormatterResult("""\
886
 
3: Joe Foo 2005-11-22 single line with trailing newline
887
 
2: Joe Foo 2005-11-22 multiline
888
 
1: Joe Foo 2005-11-22 simple log message
 
908
3: Joe Foo 2005-11-21 single line with trailing newline
 
909
2: Joe Bar 2005-11-21 multiline
 
910
1: Joe Foo 2005-11-21 simple log message
889
911
""",
890
912
            b, log.LineLogFormatter)
891
913
 
902
924
    def test_line_log_with_tags(self):
903
925
        wt = self._prepare_tree_with_merges(with_tags=True)
904
926
        self.assertFormatterResult("""\
905
 
3: Joe Foo 2005-11-22 {v1.0, v1.0rc1} rev-3
 
927
3: Jane Foo 2005-11-22 {v1.0, v1.0rc1} rev-3
906
928
2: Joe Foo 2005-11-22 [merge] {v0.2} rev-2
907
929
1: Joe Foo 2005-11-22 rev-1
908
930
""",
920
942
                committer='Line-Log-Formatter Tester <test@line.log>',
921
943
                authors=[])
922
944
        self.assertFormatterResult("""\
923
 
1: Line-Log-Formatte... 2005-11-22 add a
 
945
1: Line-Log-Formatte... 2005-11-23 add a
924
946
""",
925
947
            wt.branch, log.LineLogFormatter)
926
948
 
927
949
    def test_line_merge_revs_log_single_merge_revision(self):
928
 
        wt = self._prepare_tree_with_merges()
 
950
        wt = self.make_branch_and_memory_tree('.')
 
951
        wt.lock_write()
 
952
        self.addCleanup(wt.unlock)
 
953
        wt.add('')
 
954
        wt.commit('rev-1', rev_id='rev-1',
 
955
                  timestamp=1132586655, timezone=36000,
 
956
                  committer='Joe Foo <joe@foo.com>')
 
957
        wt.commit('rev-merged', rev_id='rev-2a',
 
958
                  timestamp=1132586700, timezone=36000,
 
959
                  committer='Joe Foo <joe@foo.com>')
 
960
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
961
        wt.branch.set_last_revision_info(1, 'rev-1')
 
962
        wt.commit('rev-2', rev_id='rev-2b',
 
963
                  timestamp=1132586800, timezone=36000,
 
964
                  committer='Joe Foo <joe@foo.com>')
929
965
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
930
966
        rev = revspec.in_history(wt.branch)
931
967
        self.assertFormatterResult("""\
936
972
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
937
973
 
938
974
    def test_line_merge_revs_log_with_merges(self):
939
 
        wt = self._prepare_tree_with_merges()
 
975
        wt = self.make_branch_and_memory_tree('.')
 
976
        wt.lock_write()
 
977
        self.addCleanup(wt.unlock)
 
978
        wt.add('')
 
979
        wt.commit('rev-1', rev_id='rev-1',
 
980
                  timestamp=1132586655, timezone=36000,
 
981
                  committer='Joe Foo <joe@foo.com>')
 
982
        wt.commit('rev-merged', rev_id='rev-2a',
 
983
                  timestamp=1132586700, timezone=36000,
 
984
                  committer='Joe Foo <joe@foo.com>')
 
985
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
986
        wt.branch.set_last_revision_info(1, 'rev-1')
 
987
        wt.commit('rev-2', rev_id='rev-2b',
 
988
                  timestamp=1132586800, timezone=36000,
 
989
                  committer='Joe Foo <joe@foo.com>')
940
990
        self.assertFormatterResult("""\
941
991
2: Joe Foo 2005-11-22 [merge] rev-2
942
992
  1.1.1: Joe Foo 2005-11-22 rev-merged
946
996
            formatter_kwargs=dict(levels=0))
947
997
 
948
998
 
949
 
class TestGnuChangelogFormatter(TestCaseForLogFormatter):
950
 
 
951
 
    def test_gnu_changelog(self):
952
 
        wt = self.make_standard_commit('nicky', authors=[])
953
 
        self.assertFormatterResult('''\
954
 
2005-11-22  Lorem Ipsum  <test@example.com>
955
 
 
956
 
\tadd a
957
 
 
958
 
''',
959
 
            wt.branch, log.GnuChangelogLogFormatter)
960
 
 
961
 
    def test_with_authors(self):
962
 
        wt = self.make_standard_commit('nicky',
963
 
            authors=['Fooa Fooz <foo@example.com>',
964
 
                     'Bari Baro <bar@example.com>'])
965
 
        self.assertFormatterResult('''\
966
 
2005-11-22  Fooa Fooz  <foo@example.com>
967
 
 
968
 
\tadd a
969
 
 
970
 
''',
971
 
            wt.branch, log.GnuChangelogLogFormatter)
972
 
 
973
 
    def test_verbose(self):
974
 
        wt = self.make_standard_commit('nicky')
975
 
        self.assertFormatterResult('''\
976
 
2005-11-22  John Doe  <jdoe@example.com>
977
 
 
978
 
\t* a:
979
 
 
980
 
\tadd a
981
 
 
982
 
''',
983
 
            wt.branch, log.GnuChangelogLogFormatter,
984
 
            show_log_kwargs=dict(verbose=True))
 
999
class TestGetViewRevisions(tests.TestCaseWithTransport):
 
1000
 
 
1001
    def make_tree_with_commits(self):
 
1002
        """Create a tree with well-known revision ids"""
 
1003
        wt = self.make_branch_and_tree('tree1')
 
1004
        wt.commit('commit one', rev_id='1')
 
1005
        wt.commit('commit two', rev_id='2')
 
1006
        wt.commit('commit three', rev_id='3')
 
1007
        mainline_revs = [None, '1', '2', '3']
 
1008
        rev_nos = {'1': 1, '2': 2, '3': 3}
 
1009
        return mainline_revs, rev_nos, wt
 
1010
 
 
1011
    def make_tree_with_merges(self):
 
1012
        """Create a tree with well-known revision ids and a merge"""
 
1013
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
 
1014
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
 
1015
        tree2.commit('four-a', rev_id='4a')
 
1016
        wt.merge_from_branch(tree2.branch)
 
1017
        wt.commit('four-b', rev_id='4b')
 
1018
        mainline_revs.append('4b')
 
1019
        rev_nos['4b'] = 4
 
1020
        # 4a: 3.1.1
 
1021
        return mainline_revs, rev_nos, wt
 
1022
 
 
1023
    def make_branch_with_many_merges(self):
 
1024
        """Create a tree with well-known revision ids"""
 
1025
        builder = self.make_branch_builder('tree1')
 
1026
        builder.start_series()
 
1027
        builder.build_snapshot('1', None, [
 
1028
            ('add', ('', 'TREE_ROOT', 'directory', '')),
 
1029
            ('add', ('f', 'f-id', 'file', '1\n'))])
 
1030
        builder.build_snapshot('2', ['1'], [])
 
1031
        builder.build_snapshot('3a', ['2'], [
 
1032
            ('modify', ('f-id', '1\n2\n3a\n'))])
 
1033
        builder.build_snapshot('3b', ['2', '3a'], [
 
1034
            ('modify', ('f-id', '1\n2\n3a\n'))])
 
1035
        builder.build_snapshot('3c', ['2', '3b'], [
 
1036
            ('modify', ('f-id', '1\n2\n3a\n'))])
 
1037
        builder.build_snapshot('4a', ['3b'], [])
 
1038
        builder.build_snapshot('4b', ['3c', '4a'], [])
 
1039
        builder.finish_series()
 
1040
 
 
1041
        # 1
 
1042
        # |
 
1043
        # 2-.
 
1044
        # |\ \
 
1045
        # | | 3a
 
1046
        # | |/
 
1047
        # | 3b
 
1048
        # |/|
 
1049
        # 3c4a
 
1050
        # |/
 
1051
        # 4b
 
1052
 
 
1053
        mainline_revs = [None, '1', '2', '3c', '4b']
 
1054
        rev_nos = {'1':1, '2':2, '3c': 3, '4b':4}
 
1055
        full_rev_nos_for_reference = {
 
1056
            '1': '1',
 
1057
            '2': '2',
 
1058
            '3a': '2.1.1', #first commit tree 3
 
1059
            '3b': '2.2.1', # first commit tree 2
 
1060
            '3c': '3', #merges 3b to main
 
1061
            '4a': '2.2.2', # second commit tree 2
 
1062
            '4b': '4', # merges 4a to main
 
1063
            }
 
1064
        return mainline_revs, rev_nos, builder.get_branch()
 
1065
 
 
1066
    def test_get_view_revisions_forward(self):
 
1067
        """Test the get_view_revisions method"""
 
1068
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
 
1069
        wt.lock_read()
 
1070
        self.addCleanup(wt.unlock)
 
1071
        revisions = list(log.get_view_revisions(
 
1072
                mainline_revs, rev_nos, wt.branch, 'forward'))
 
1073
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0)],
 
1074
                         revisions)
 
1075
        revisions2 = list(log.get_view_revisions(
 
1076
                mainline_revs, rev_nos, wt.branch, 'forward',
 
1077
                include_merges=False))
 
1078
        self.assertEqual(revisions, revisions2)
 
1079
 
 
1080
    def test_get_view_revisions_reverse(self):
 
1081
        """Test the get_view_revisions with reverse"""
 
1082
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
 
1083
        wt.lock_read()
 
1084
        self.addCleanup(wt.unlock)
 
1085
        revisions = list(log.get_view_revisions(
 
1086
                mainline_revs, rev_nos, wt.branch, 'reverse'))
 
1087
        self.assertEqual([('3', '3', 0), ('2', '2', 0), ('1', '1', 0), ],
 
1088
                         revisions)
 
1089
        revisions2 = list(log.get_view_revisions(
 
1090
                mainline_revs, rev_nos, wt.branch, 'reverse',
 
1091
                include_merges=False))
 
1092
        self.assertEqual(revisions, revisions2)
 
1093
 
 
1094
    def test_get_view_revisions_merge(self):
 
1095
        """Test get_view_revisions when there are merges"""
 
1096
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
 
1097
        wt.lock_read()
 
1098
        self.addCleanup(wt.unlock)
 
1099
        revisions = list(log.get_view_revisions(
 
1100
                mainline_revs, rev_nos, wt.branch, 'forward'))
 
1101
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0),
 
1102
                          ('4b', '4', 0), ('4a', '3.1.1', 1)],
 
1103
                         revisions)
 
1104
        revisions = list(log.get_view_revisions(
 
1105
                mainline_revs, rev_nos, wt.branch, 'forward',
 
1106
                include_merges=False))
 
1107
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0),
 
1108
                          ('4b', '4', 0)],
 
1109
                         revisions)
 
1110
 
 
1111
    def test_get_view_revisions_merge_reverse(self):
 
1112
        """Test get_view_revisions in reverse when there are merges"""
 
1113
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
 
1114
        wt.lock_read()
 
1115
        self.addCleanup(wt.unlock)
 
1116
        revisions = list(log.get_view_revisions(
 
1117
                mainline_revs, rev_nos, wt.branch, 'reverse'))
 
1118
        self.assertEqual([('4b', '4', 0), ('4a', '3.1.1', 1),
 
1119
                          ('3', '3', 0), ('2', '2', 0), ('1', '1', 0)],
 
1120
                         revisions)
 
1121
        revisions = list(log.get_view_revisions(
 
1122
                mainline_revs, rev_nos, wt.branch, 'reverse',
 
1123
                include_merges=False))
 
1124
        self.assertEqual([('4b', '4', 0), ('3', '3', 0), ('2', '2', 0),
 
1125
                          ('1', '1', 0)],
 
1126
                         revisions)
 
1127
 
 
1128
    def test_get_view_revisions_merge2(self):
 
1129
        """Test get_view_revisions when there are merges"""
 
1130
        mainline_revs, rev_nos, b = self.make_branch_with_many_merges()
 
1131
        b.lock_read()
 
1132
        self.addCleanup(b.unlock)
 
1133
        revisions = list(log.get_view_revisions(
 
1134
                mainline_revs, rev_nos, b, 'forward'))
 
1135
        expected = [('1', '1', 0), ('2', '2', 0), ('3c', '3', 0),
 
1136
                    ('3b', '2.2.1', 1), ('3a', '2.1.1', 2), ('4b', '4', 0),
 
1137
                    ('4a', '2.2.2', 1)]
 
1138
        self.assertEqual(expected, revisions)
 
1139
        revisions = list(log.get_view_revisions(
 
1140
                mainline_revs, rev_nos, b, 'forward',
 
1141
                include_merges=False))
 
1142
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3c', '3', 0),
 
1143
                          ('4b', '4', 0)],
 
1144
                         revisions)
 
1145
 
 
1146
 
 
1147
    def test_file_id_for_range(self):
 
1148
        mainline_revs, rev_nos, b = self.make_branch_with_many_merges()
 
1149
        b.lock_read()
 
1150
        self.addCleanup(b.unlock)
 
1151
 
 
1152
        def rev_from_rev_id(revid, branch):
 
1153
            revspec = revisionspec.RevisionSpec.from_string('revid:%s' % revid)
 
1154
            return revspec.in_history(branch)
 
1155
 
 
1156
        def view_revs(start_rev, end_rev, file_id, direction):
 
1157
            revs = log.calculate_view_revisions(
 
1158
                b,
 
1159
                start_rev, # start_revision
 
1160
                end_rev, # end_revision
 
1161
                direction, # direction
 
1162
                file_id, # specific_fileid
 
1163
                True, # generate_merge_revisions
 
1164
                )
 
1165
            return revs
 
1166
 
 
1167
        rev_3a = rev_from_rev_id('3a', b)
 
1168
        rev_4b = rev_from_rev_id('4b', b)
 
1169
        self.assertEqual([('3c', '3', 0), ('3b', '2.2.1', 1), ('3a', '2.1.1', 2)],
 
1170
                          view_revs(rev_3a, rev_4b, 'f-id', 'reverse'))
 
1171
        # Note: 3c still appears before 3a here because of depth-based sorting
 
1172
        self.assertEqual([('3c', '3', 0), ('3b', '2.2.1', 1), ('3a', '2.1.1', 2)],
 
1173
                          view_revs(rev_3a, rev_4b, 'f-id', 'forward'))
 
1174
 
 
1175
 
 
1176
class TestGetRevisionsTouchingFileID(tests.TestCaseWithTransport):
 
1177
 
 
1178
    def create_tree_with_single_merge(self):
 
1179
        """Create a branch with a moderate layout.
 
1180
 
 
1181
        The revision graph looks like:
 
1182
 
 
1183
           A
 
1184
           |\
 
1185
           B C
 
1186
           |/
 
1187
           D
 
1188
 
 
1189
        In this graph, A introduced files f1 and f2 and f3.
 
1190
        B modifies f1 and f3, and C modifies f2 and f3.
 
1191
        D merges the changes from B and C and resolves the conflict for f3.
 
1192
        """
 
1193
        # TODO: jam 20070218 This seems like it could really be done
 
1194
        #       with make_branch_and_memory_tree() if we could just
 
1195
        #       create the content of those files.
 
1196
        # TODO: jam 20070218 Another alternative is that we would really
 
1197
        #       like to only create this tree 1 time for all tests that
 
1198
        #       use it. Since 'log' only uses the tree in a readonly
 
1199
        #       fashion, it seems a shame to regenerate an identical
 
1200
        #       tree for each test.
 
1201
        tree = self.make_branch_and_tree('tree')
 
1202
        tree.lock_write()
 
1203
        self.addCleanup(tree.unlock)
 
1204
 
 
1205
        self.build_tree_contents([('tree/f1', 'A\n'),
 
1206
                                  ('tree/f2', 'A\n'),
 
1207
                                  ('tree/f3', 'A\n'),
 
1208
                                 ])
 
1209
        tree.add(['f1', 'f2', 'f3'], ['f1-id', 'f2-id', 'f3-id'])
 
1210
        tree.commit('A', rev_id='A')
 
1211
 
 
1212
        self.build_tree_contents([('tree/f2', 'A\nC\n'),
 
1213
                                  ('tree/f3', 'A\nC\n'),
 
1214
                                 ])
 
1215
        tree.commit('C', rev_id='C')
 
1216
        # Revert back to A to build the other history.
 
1217
        tree.set_last_revision('A')
 
1218
        tree.branch.set_last_revision_info(1, 'A')
 
1219
        self.build_tree_contents([('tree/f1', 'A\nB\n'),
 
1220
                                  ('tree/f2', 'A\n'),
 
1221
                                  ('tree/f3', 'A\nB\n'),
 
1222
                                 ])
 
1223
        tree.commit('B', rev_id='B')
 
1224
        tree.set_parent_ids(['B', 'C'])
 
1225
        self.build_tree_contents([('tree/f1', 'A\nB\n'),
 
1226
                                  ('tree/f2', 'A\nC\n'),
 
1227
                                  ('tree/f3', 'A\nB\nC\n'),
 
1228
                                 ])
 
1229
        tree.commit('D', rev_id='D')
 
1230
 
 
1231
        # Switch to a read lock for this tree.
 
1232
        # We still have an addCleanup(tree.unlock) pending
 
1233
        tree.unlock()
 
1234
        tree.lock_read()
 
1235
        return tree
 
1236
 
 
1237
    def check_delta(self, delta, **kw):
 
1238
        """Check the filenames touched by a delta are as expected.
 
1239
 
 
1240
        Caller only have to pass in the list of files for each part, all
 
1241
        unspecified parts are considered empty (and checked as such).
 
1242
        """
 
1243
        for n in 'added', 'removed', 'renamed', 'modified', 'unchanged':
 
1244
            # By default we expect an empty list
 
1245
            expected = kw.get(n, [])
 
1246
            # strip out only the path components
 
1247
            got = [x[0] for x in getattr(delta, n)]
 
1248
            self.assertEqual(expected, got)
 
1249
 
 
1250
    def test_tree_with_single_merge(self):
 
1251
        """Make sure the tree layout is correct."""
 
1252
        tree = self.create_tree_with_single_merge()
 
1253
        rev_A_tree = tree.branch.repository.revision_tree('A')
 
1254
        rev_B_tree = tree.branch.repository.revision_tree('B')
 
1255
        rev_C_tree = tree.branch.repository.revision_tree('C')
 
1256
        rev_D_tree = tree.branch.repository.revision_tree('D')
 
1257
 
 
1258
        self.check_delta(rev_B_tree.changes_from(rev_A_tree),
 
1259
                         modified=['f1', 'f3'])
 
1260
 
 
1261
        self.check_delta(rev_C_tree.changes_from(rev_A_tree),
 
1262
                         modified=['f2', 'f3'])
 
1263
 
 
1264
        self.check_delta(rev_D_tree.changes_from(rev_B_tree),
 
1265
                         modified=['f2', 'f3'])
 
1266
 
 
1267
        self.check_delta(rev_D_tree.changes_from(rev_C_tree),
 
1268
                         modified=['f1', 'f3'])
 
1269
 
 
1270
    def assertAllRevisionsForFileID(self, tree, file_id, revisions):
 
1271
        """Ensure _filter_revisions_touching_file_id returns the right values.
 
1272
 
 
1273
        Get the return value from _filter_revisions_touching_file_id and make
 
1274
        sure they are correct.
 
1275
        """
 
1276
        # The api for _filter_revisions_touching_file_id is a little crazy.
 
1277
        # So we do the setup here.
 
1278
        mainline = tree.branch.revision_history()
 
1279
        mainline.insert(0, None)
 
1280
        revnos = dict((rev, idx+1) for idx, rev in enumerate(mainline))
 
1281
        view_revs_iter = log.get_view_revisions(mainline, revnos, tree.branch,
 
1282
                                                'reverse', True)
 
1283
        actual_revs = log._filter_revisions_touching_file_id(
 
1284
                            tree.branch,
 
1285
                            file_id,
 
1286
                            list(view_revs_iter))
 
1287
        self.assertEqual(revisions, [r for r, revno, depth in actual_revs])
 
1288
 
 
1289
    def test_file_id_f1(self):
 
1290
        tree = self.create_tree_with_single_merge()
 
1291
        # f1 should be marked as modified by revisions A and B
 
1292
        self.assertAllRevisionsForFileID(tree, 'f1-id', ['B', 'A'])
 
1293
 
 
1294
    def test_file_id_f2(self):
 
1295
        tree = self.create_tree_with_single_merge()
 
1296
        # f2 should be marked as modified by revisions A, C, and D
 
1297
        # because D merged the changes from C.
 
1298
        self.assertAllRevisionsForFileID(tree, 'f2-id', ['D', 'C', 'A'])
 
1299
 
 
1300
    def test_file_id_f3(self):
 
1301
        tree = self.create_tree_with_single_merge()
 
1302
        # f3 should be marked as modified by revisions A, B, C, and D
 
1303
        self.assertAllRevisionsForFileID(tree, 'f3-id', ['D', 'C', 'B', 'A'])
 
1304
 
 
1305
    def test_file_id_with_ghosts(self):
 
1306
        # This is testing bug #209948, where having a ghost would cause
 
1307
        # _filter_revisions_touching_file_id() to fail.
 
1308
        tree = self.create_tree_with_single_merge()
 
1309
        # We need to add a revision, so switch back to a write-locked tree
 
1310
        # (still a single addCleanup(tree.unlock) pending).
 
1311
        tree.unlock()
 
1312
        tree.lock_write()
 
1313
        first_parent = tree.last_revision()
 
1314
        tree.set_parent_ids([first_parent, 'ghost-revision-id'])
 
1315
        self.build_tree_contents([('tree/f1', 'A\nB\nXX\n')])
 
1316
        tree.commit('commit with a ghost', rev_id='XX')
 
1317
        self.assertAllRevisionsForFileID(tree, 'f1-id', ['XX', 'B', 'A'])
 
1318
        self.assertAllRevisionsForFileID(tree, 'f2-id', ['D', 'C', 'A'])
 
1319
 
 
1320
    def test_unknown_file_id(self):
 
1321
        tree = self.create_tree_with_single_merge()
 
1322
        self.assertAllRevisionsForFileID(tree, 'unknown', [])
 
1323
 
 
1324
    def test_empty_branch_unknown_file_id(self):
 
1325
        tree = self.make_branch_and_tree('tree')
 
1326
        self.assertAllRevisionsForFileID(tree, 'unknown', [])
985
1327
 
986
1328
 
987
1329
class TestShowChangedRevisions(tests.TestCaseWithTransport):
999
1341
 
1000
1342
class TestLogFormatter(tests.TestCase):
1001
1343
 
1002
 
    def setUp(self):
1003
 
        super(TestLogFormatter, self).setUp()
1004
 
        self.rev = revision.Revision('a-id')
1005
 
        self.lf = log.LogFormatter(None)
1006
 
 
1007
1344
    def test_short_committer(self):
1008
 
        def assertCommitter(expected, committer):
1009
 
            self.rev.committer = committer
1010
 
            self.assertEqual(expected, self.lf.short_committer(self.rev))
1011
 
 
1012
 
        assertCommitter('John Doe', 'John Doe <jdoe@example.com>')
1013
 
        assertCommitter('John Smith', 'John Smith <jsmith@example.com>')
1014
 
        assertCommitter('John Smith', 'John Smith')
1015
 
        assertCommitter('jsmith@example.com', 'jsmith@example.com')
1016
 
        assertCommitter('jsmith@example.com', '<jsmith@example.com>')
1017
 
        assertCommitter('John Smith', 'John Smith jsmith@example.com')
 
1345
        rev = revision.Revision('a-id')
 
1346
        rev.committer = 'John Doe <jdoe@example.com>'
 
1347
        lf = log.LogFormatter(None)
 
1348
        self.assertEqual('John Doe', lf.short_committer(rev))
 
1349
        rev.committer = 'John Smith <jsmith@example.com>'
 
1350
        self.assertEqual('John Smith', lf.short_committer(rev))
 
1351
        rev.committer = 'John Smith'
 
1352
        self.assertEqual('John Smith', lf.short_committer(rev))
 
1353
        rev.committer = 'jsmith@example.com'
 
1354
        self.assertEqual('jsmith@example.com', lf.short_committer(rev))
 
1355
        rev.committer = '<jsmith@example.com>'
 
1356
        self.assertEqual('jsmith@example.com', lf.short_committer(rev))
 
1357
        rev.committer = 'John Smith jsmith@example.com'
 
1358
        self.assertEqual('John Smith', lf.short_committer(rev))
1018
1359
 
1019
1360
    def test_short_author(self):
1020
 
        def assertAuthor(expected, author):
1021
 
            self.rev.properties['author'] = author
1022
 
            self.assertEqual(expected, self.lf.short_author(self.rev))
1023
 
 
1024
 
        assertAuthor('John Smith', 'John Smith <jsmith@example.com>')
1025
 
        assertAuthor('John Smith', 'John Smith')
1026
 
        assertAuthor('jsmith@example.com', 'jsmith@example.com')
1027
 
        assertAuthor('jsmith@example.com', '<jsmith@example.com>')
1028
 
        assertAuthor('John Smith', 'John Smith jsmith@example.com')
1029
 
 
1030
 
    def test_short_author_from_committer(self):
1031
 
        self.rev.committer = 'John Doe <jdoe@example.com>'
1032
 
        self.assertEqual('John Doe', self.lf.short_author(self.rev))
1033
 
 
1034
 
    def test_short_author_from_authors(self):
1035
 
        self.rev.properties['authors'] = ('John Smith <jsmith@example.com>\n'
1036
 
                                          'Jane Rey <jrey@example.com>')
1037
 
        self.assertEqual('John Smith', self.lf.short_author(self.rev))
 
1361
        rev = revision.Revision('a-id')
 
1362
        rev.committer = 'John Doe <jdoe@example.com>'
 
1363
        lf = log.LogFormatter(None)
 
1364
        self.assertEqual('John Doe', lf.short_author(rev))
 
1365
        rev.properties['author'] = 'John Smith <jsmith@example.com>'
 
1366
        self.assertEqual('John Smith', lf.short_author(rev))
 
1367
        rev.properties['author'] = 'John Smith'
 
1368
        self.assertEqual('John Smith', lf.short_author(rev))
 
1369
        rev.properties['author'] = 'jsmith@example.com'
 
1370
        self.assertEqual('jsmith@example.com', lf.short_author(rev))
 
1371
        rev.properties['author'] = '<jsmith@example.com>'
 
1372
        self.assertEqual('jsmith@example.com', lf.short_author(rev))
 
1373
        rev.properties['author'] = 'John Smith jsmith@example.com'
 
1374
        self.assertEqual('John Smith', lf.short_author(rev))
 
1375
        del rev.properties['author']
 
1376
        rev.properties['authors'] = ('John Smith <jsmith@example.com>\n'
 
1377
                'Jane Rey <jrey@example.com>')
 
1378
        self.assertEqual('John Smith', lf.short_author(rev))
1038
1379
 
1039
1380
 
1040
1381
class TestReverseByDepth(tests.TestCase):
1188
1529
        self.assertNotContainsRe(s.getvalue(), 'Added Revisions:')
1189
1530
 
1190
1531
 
1191
 
class TestRevisionNotInBranch(TestCaseForLogFormatter):
1192
 
 
1193
 
    def setup_a_tree(self):
1194
 
        tree = self.make_branch_and_tree('tree')
1195
 
        tree.lock_write()
1196
 
        self.addCleanup(tree.unlock)
1197
 
        kwargs = {
1198
 
            'committer': 'Joe Foo <joe@foo.com>',
1199
 
            'timestamp': 1132617600, # Mon 2005-11-22 00:00:00 +0000
1200
 
            'timezone': 0, # UTC
1201
 
        }
1202
 
        tree.commit('commit 1a', rev_id='1a', **kwargs)
1203
 
        tree.commit('commit 2a', rev_id='2a', **kwargs)
1204
 
        tree.commit('commit 3a', rev_id='3a', **kwargs)
1205
 
        return tree
1206
 
 
1207
 
    def setup_ab_tree(self):
1208
 
        tree = self.setup_a_tree()
1209
 
        tree.set_last_revision('1a')
1210
 
        tree.branch.set_last_revision_info(1, '1a')
1211
 
        kwargs = {
1212
 
            'committer': 'Joe Foo <joe@foo.com>',
1213
 
            'timestamp': 1132617600, # Mon 2005-11-22 00:00:00 +0000
1214
 
            'timezone': 0, # UTC
1215
 
        }
1216
 
        tree.commit('commit 2b', rev_id='2b', **kwargs)
1217
 
        tree.commit('commit 3b', rev_id='3b', **kwargs)
1218
 
        return tree
1219
 
 
1220
 
    def test_one_revision(self):
1221
 
        tree = self.setup_ab_tree()
1222
 
        lf = LogCatcher()
1223
 
        rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1224
 
        log.show_log(tree.branch, lf, verbose=True, start_revision=rev,
1225
 
                     end_revision=rev)
1226
 
        self.assertEqual(1, len(lf.revisions))
1227
 
        self.assertEqual(None, lf.revisions[0].revno)   # Out-of-branch
1228
 
        self.assertEqual('3a', lf.revisions[0].rev.revision_id)
1229
 
 
1230
 
    def test_many_revisions(self):
1231
 
        tree = self.setup_ab_tree()
1232
 
        lf = LogCatcher()
1233
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
1234
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1235
 
        log.show_log(tree.branch, lf, verbose=True, start_revision=start_rev,
1236
 
                     end_revision=end_rev)
1237
 
        self.assertEqual(3, len(lf.revisions))
1238
 
        self.assertEqual(None, lf.revisions[0].revno)   # Out-of-branch
1239
 
        self.assertEqual('3a', lf.revisions[0].rev.revision_id)
1240
 
        self.assertEqual(None, lf.revisions[1].revno)   # Out-of-branch
1241
 
        self.assertEqual('2a', lf.revisions[1].rev.revision_id)
1242
 
        self.assertEqual('1', lf.revisions[2].revno)    # In-branch
1243
 
 
1244
 
    def test_long_format(self):
1245
 
        tree = self.setup_ab_tree()
1246
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
1247
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1248
 
        self.assertFormatterResult("""\
1249
 
------------------------------------------------------------
1250
 
revision-id: 3a
1251
 
committer: Joe Foo <joe@foo.com>
1252
 
branch nick: tree
1253
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1254
 
message:
1255
 
  commit 3a
1256
 
------------------------------------------------------------
1257
 
revision-id: 2a
1258
 
committer: Joe Foo <joe@foo.com>
1259
 
branch nick: tree
1260
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1261
 
message:
1262
 
  commit 2a
1263
 
------------------------------------------------------------
1264
 
revno: 1
1265
 
committer: Joe Foo <joe@foo.com>
1266
 
branch nick: tree
1267
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1268
 
message:
1269
 
  commit 1a
1270
 
""",
1271
 
            tree.branch, log.LongLogFormatter, show_log_kwargs={
1272
 
                'start_revision': start_rev, 'end_revision': end_rev
1273
 
            })
1274
 
 
1275
 
    def test_short_format(self):
1276
 
        tree = self.setup_ab_tree()
1277
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
1278
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1279
 
        self.assertFormatterResult("""\
1280
 
      Joe Foo\t2005-11-22
1281
 
      revision-id:3a
1282
 
      commit 3a
1283
 
 
1284
 
      Joe Foo\t2005-11-22
1285
 
      revision-id:2a
1286
 
      commit 2a
1287
 
 
1288
 
    1 Joe Foo\t2005-11-22
1289
 
      commit 1a
1290
 
 
1291
 
""",
1292
 
            tree.branch, log.ShortLogFormatter, show_log_kwargs={
1293
 
                'start_revision': start_rev, 'end_revision': end_rev
1294
 
            })
1295
 
 
1296
 
    def test_line_format(self):
1297
 
        tree = self.setup_ab_tree()
1298
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
1299
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1300
 
        self.assertFormatterResult("""\
1301
 
Joe Foo 2005-11-22 commit 3a
1302
 
Joe Foo 2005-11-22 commit 2a
1303
 
1: Joe Foo 2005-11-22 commit 1a
1304
 
""",
1305
 
            tree.branch, log.LineLogFormatter, show_log_kwargs={
1306
 
                'start_revision': start_rev, 'end_revision': end_rev
1307
 
            })
1308
 
 
1309
 
 
1310
 
class TestLogWithBugs(TestCaseForLogFormatter, TestLogMixin):
 
1532
 
 
1533
class TestLogWithBugs(TestCaseForLogFormatter):
1311
1534
 
1312
1535
    def setUp(self):
1313
1536
        TestCaseForLogFormatter.setUp(self)
1320
1543
        tree = self.make_branch_and_tree(u'.')
1321
1544
        self.build_tree(['a', 'b'])
1322
1545
        tree.add('a')
1323
 
        self.wt_commit(tree, 'simple log message', rev_id='a1',
1324
 
                       revprops={'bugs': 'test://bug/id fixed'})
 
1546
        tree.commit('simple log message', rev_id='a1',
 
1547
                    timestamp=1132586655.459960938, timezone=-6*3600,
 
1548
                    committer='Joe Foo <joe@foo.com>',
 
1549
                    revprops={'bugs': 'test://bug/id fixed'})
1325
1550
        tree.add('b')
1326
 
        self.wt_commit(tree, 'multiline\nlog\nmessage\n', rev_id='a2',
1327
 
                       authors=['Joe Bar <joe@bar.com>'],
1328
 
                       revprops={'bugs': 'test://bug/id fixed\n'
1329
 
                                 'test://bug/2 fixed'})
 
1551
        tree.commit('multiline\nlog\nmessage\n', rev_id='a2',
 
1552
                    timestamp=1132586842.411175966, timezone=-6*3600,
 
1553
                    committer='Joe Foo <joe@foo.com>',
 
1554
                    authors=['Joe Bar <joe@bar.com>'],
 
1555
                    revprops={'bugs': 'test://bug/id fixed\n'
 
1556
                                      'test://bug/2 fixed'})
1330
1557
        return tree
1331
1558
 
1332
1559
 
1339
1566
author: Joe Bar <joe@bar.com>
1340
1567
committer: Joe Foo <joe@foo.com>
1341
1568
branch nick: work
1342
 
timestamp: Tue 2005-11-22 00:00:01 +0000
 
1569
timestamp: Mon 2005-11-21 09:27:22 -0600
1343
1570
message:
1344
1571
  multiline
1345
1572
  log
1349
1576
fixes bug(s): test://bug/id
1350
1577
committer: Joe Foo <joe@foo.com>
1351
1578
branch nick: work
1352
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
1579
timestamp: Mon 2005-11-21 09:24:15 -0600
1353
1580
message:
1354
1581
  simple log message
1355
1582
""",
1358
1585
    def test_short_bugs(self):
1359
1586
        tree = self.make_commits_with_bugs()
1360
1587
        self.assertFormatterResult("""\
1361
 
    2 Joe Bar\t2005-11-22
 
1588
    2 Joe Bar\t2005-11-21
1362
1589
      fixes bug(s): test://bug/id test://bug/2
1363
1590
      multiline
1364
1591
      log
1365
1592
      message
1366
1593
 
1367
 
    1 Joe Foo\t2005-11-22
 
1594
    1 Joe Foo\t2005-11-21
1368
1595
      fixes bug(s): test://bug/id
1369
1596
      simple log message
1370
1597
 
1374
1601
    def test_wrong_bugs_property(self):
1375
1602
        tree = self.make_branch_and_tree(u'.')
1376
1603
        self.build_tree(['foo'])
1377
 
        self.wt_commit(tree, 'simple log message', rev_id='a1',
1378
 
                       revprops={'bugs': 'test://bug/id invalid_value'})
 
1604
        tree.commit('simple log message', rev_id='a1',
 
1605
              timestamp=1132586655.459960938, timezone=-6*3600,
 
1606
              committer='Joe Foo <joe@foo.com>',
 
1607
              revprops={'bugs': 'test://bug/id invalid_value'})
1379
1608
        self.assertFormatterResult("""\
1380
 
    1 Joe Foo\t2005-11-22
 
1609
    1 Joe Foo\t2005-11-21
1381
1610
      simple log message
1382
1611
 
1383
1612
""",
1385
1614
 
1386
1615
    def test_bugs_handler_present(self):
1387
1616
        self.properties_handler_registry.get('bugs_properties_handler')
1388
 
 
1389
 
 
1390
 
class TestLogForAuthors(TestCaseForLogFormatter):
1391
 
 
1392
 
    def setUp(self):
1393
 
        TestCaseForLogFormatter.setUp(self)
1394
 
        self.wt = self.make_standard_commit('nicky',
1395
 
            authors=['John Doe <jdoe@example.com>',
1396
 
                     'Jane Rey <jrey@example.com>'])
1397
 
 
1398
 
    def assertFormatterResult(self, formatter, who, result):
1399
 
        formatter_kwargs = dict()
1400
 
        if who is not None:
1401
 
            author_list_handler = log.author_list_registry.get(who)
1402
 
            formatter_kwargs['author_list_handler'] = author_list_handler
1403
 
        TestCaseForLogFormatter.assertFormatterResult(self, result,
1404
 
            self.wt.branch, formatter, formatter_kwargs=formatter_kwargs)
1405
 
 
1406
 
    def test_line_default(self):
1407
 
        self.assertFormatterResult(log.LineLogFormatter, None, """\
1408
 
1: John Doe 2005-11-22 add a
1409
 
""")
1410
 
 
1411
 
    def test_line_committer(self):
1412
 
        self.assertFormatterResult(log.LineLogFormatter, 'committer', """\
1413
 
1: Lorem Ipsum 2005-11-22 add a
1414
 
""")
1415
 
 
1416
 
    def test_line_first(self):
1417
 
        self.assertFormatterResult(log.LineLogFormatter, 'first', """\
1418
 
1: John Doe 2005-11-22 add a
1419
 
""")
1420
 
 
1421
 
    def test_line_all(self):
1422
 
        self.assertFormatterResult(log.LineLogFormatter, 'all', """\
1423
 
1: John Doe, Jane Rey 2005-11-22 add a
1424
 
""")
1425
 
 
1426
 
 
1427
 
    def test_short_default(self):
1428
 
        self.assertFormatterResult(log.ShortLogFormatter, None, """\
1429
 
    1 John Doe\t2005-11-22
1430
 
      add a
1431
 
 
1432
 
""")
1433
 
 
1434
 
    def test_short_committer(self):
1435
 
        self.assertFormatterResult(log.ShortLogFormatter, 'committer', """\
1436
 
    1 Lorem Ipsum\t2005-11-22
1437
 
      add a
1438
 
 
1439
 
""")
1440
 
 
1441
 
    def test_short_first(self):
1442
 
        self.assertFormatterResult(log.ShortLogFormatter, 'first', """\
1443
 
    1 John Doe\t2005-11-22
1444
 
      add a
1445
 
 
1446
 
""")
1447
 
 
1448
 
    def test_short_all(self):
1449
 
        self.assertFormatterResult(log.ShortLogFormatter, 'all', """\
1450
 
    1 John Doe, Jane Rey\t2005-11-22
1451
 
      add a
1452
 
 
1453
 
""")
1454
 
 
1455
 
    def test_long_default(self):
1456
 
        self.assertFormatterResult(log.LongLogFormatter, None, """\
1457
 
------------------------------------------------------------
1458
 
revno: 1
1459
 
author: John Doe <jdoe@example.com>, Jane Rey <jrey@example.com>
1460
 
committer: Lorem Ipsum <test@example.com>
1461
 
branch nick: nicky
1462
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1463
 
message:
1464
 
  add a
1465
 
""")
1466
 
 
1467
 
    def test_long_committer(self):
1468
 
        self.assertFormatterResult(log.LongLogFormatter, 'committer', """\
1469
 
------------------------------------------------------------
1470
 
revno: 1
1471
 
committer: Lorem Ipsum <test@example.com>
1472
 
branch nick: nicky
1473
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1474
 
message:
1475
 
  add a
1476
 
""")
1477
 
 
1478
 
    def test_long_first(self):
1479
 
        self.assertFormatterResult(log.LongLogFormatter, 'first', """\
1480
 
------------------------------------------------------------
1481
 
revno: 1
1482
 
author: John Doe <jdoe@example.com>
1483
 
committer: Lorem Ipsum <test@example.com>
1484
 
branch nick: nicky
1485
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1486
 
message:
1487
 
  add a
1488
 
""")
1489
 
 
1490
 
    def test_long_all(self):
1491
 
        self.assertFormatterResult(log.LongLogFormatter, 'all', """\
1492
 
------------------------------------------------------------
1493
 
revno: 1
1494
 
author: John Doe <jdoe@example.com>, Jane Rey <jrey@example.com>
1495
 
committer: Lorem Ipsum <test@example.com>
1496
 
branch nick: nicky
1497
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1498
 
message:
1499
 
  add a
1500
 
""")
1501
 
 
1502
 
    def test_gnu_changelog_default(self):
1503
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, None, """\
1504
 
2005-11-22  John Doe  <jdoe@example.com>
1505
 
 
1506
 
\tadd a
1507
 
 
1508
 
""")
1509
 
 
1510
 
    def test_gnu_changelog_committer(self):
1511
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'committer', """\
1512
 
2005-11-22  Lorem Ipsum  <test@example.com>
1513
 
 
1514
 
\tadd a
1515
 
 
1516
 
""")
1517
 
 
1518
 
    def test_gnu_changelog_first(self):
1519
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'first', """\
1520
 
2005-11-22  John Doe  <jdoe@example.com>
1521
 
 
1522
 
\tadd a
1523
 
 
1524
 
""")
1525
 
 
1526
 
    def test_gnu_changelog_all(self):
1527
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'all', """\
1528
 
2005-11-22  John Doe  <jdoe@example.com>, Jane Rey  <jrey@example.com>
1529
 
 
1530
 
\tadd a
1531
 
 
1532
 
""")
1533
 
 
1534
 
 
1535
 
class TestLogExcludeAncestry(tests.TestCaseWithTransport):
1536
 
 
1537
 
    def make_branch_with_alternate_ancestries(self, relpath='.'):
1538
 
        # See test_merge_sorted_exclude_ancestry below for the difference with
1539
 
        # bt.per_branch.test_iter_merge_sorted_revision.
1540
 
        # TestIterMergeSortedRevisionsBushyGraph.
1541
 
        # make_branch_with_alternate_ancestries
1542
 
        # and test_merge_sorted_exclude_ancestry
1543
 
        # See the FIXME in assertLogRevnos too.
1544
 
        builder = branchbuilder.BranchBuilder(self.get_transport(relpath))
1545
 
        # 1
1546
 
        # |\
1547
 
        # 2 \
1548
 
        # |  |
1549
 
        # |  1.1.1
1550
 
        # |  | \
1551
 
        # |  |  1.2.1
1552
 
        # |  | /
1553
 
        # |  1.1.2
1554
 
        # | /
1555
 
        # 3
1556
 
        builder.start_series()
1557
 
        builder.build_snapshot('1', None, [
1558
 
            ('add', ('', 'TREE_ROOT', 'directory', '')),])
1559
 
        builder.build_snapshot('1.1.1', ['1'], [])
1560
 
        builder.build_snapshot('2', ['1'], [])
1561
 
        builder.build_snapshot('1.2.1', ['1.1.1'], [])
1562
 
        builder.build_snapshot('1.1.2', ['1.1.1', '1.2.1'], [])
1563
 
        builder.build_snapshot('3', ['2', '1.1.2'], [])
1564
 
        builder.finish_series()
1565
 
        br = builder.get_branch()
1566
 
        br.lock_read()
1567
 
        self.addCleanup(br.unlock)
1568
 
        return br
1569
 
 
1570
 
    def assertLogRevnos(self, expected_revnos, b, start, end,
1571
 
                        exclude_common_ancestry, generate_merge_revisions=True):
1572
 
        # FIXME: the layering in log makes it hard to test intermediate levels,
1573
 
        # I wish adding filters with their parameters were easier...
1574
 
        # -- vila 20100413
1575
 
        iter_revs = log._calc_view_revisions(
1576
 
            b, start, end, direction='reverse',
1577
 
            generate_merge_revisions=generate_merge_revisions,
1578
 
            exclude_common_ancestry=exclude_common_ancestry)
1579
 
        self.assertEqual(expected_revnos,
1580
 
                         [revid for revid, revno, depth in iter_revs])
1581
 
 
1582
 
    def test_merge_sorted_exclude_ancestry(self):
1583
 
        b = self.make_branch_with_alternate_ancestries()
1584
 
        self.assertLogRevnos(['3', '1.1.2', '1.2.1', '1.1.1', '2', '1'],
1585
 
                             b, '1', '3', exclude_common_ancestry=False)
1586
 
        # '2' is part of the '3' ancestry but not part of '1.1.1' ancestry so
1587
 
        # it should be mentioned even if merge_sort order will make it appear
1588
 
        # after 1.1.1
1589
 
        self.assertLogRevnos(['3', '1.1.2', '1.2.1', '2'],
1590
 
                             b, '1.1.1', '3', exclude_common_ancestry=True)
1591
 
 
1592
 
    def test_merge_sorted_simple_revnos_exclude_ancestry(self):
1593
 
        b = self.make_branch_with_alternate_ancestries()
1594
 
        self.assertLogRevnos(['3', '2'],
1595
 
                             b, '1', '3', exclude_common_ancestry=True,
1596
 
                             generate_merge_revisions=False)
1597
 
        self.assertLogRevnos(['3', '1.1.2', '1.2.1', '1.1.1', '2'],
1598
 
                             b, '1', '3', exclude_common_ancestry=True,
1599
 
                             generate_merge_revisions=True)
1600
 
 
1601
 
 
1602
 
class TestLogDefaults(TestCaseForLogFormatter):
1603
 
    def test_default_log_level(self):
1604
 
        """
1605
 
        Test to ensure that specifying 'levels=1' to make_log_request_dict
1606
 
        doesn't get overwritten when using a LogFormatter that supports more
1607
 
        detail.
1608
 
        Fixes bug #747958.
1609
 
        """
1610
 
        wt = self._prepare_tree_with_merges()
1611
 
        b = wt.branch
1612
 
 
1613
 
        class CustomLogFormatter(log.LogFormatter):
1614
 
            def __init__(self, *args, **kwargs):
1615
 
                super(CustomLogFormatter, self).__init__(*args, **kwargs)
1616
 
                self.revisions = []
1617
 
            def get_levels(self):
1618
 
                # log formatter supports all levels:
1619
 
                return 0
1620
 
            def log_revision(self, revision):
1621
 
                self.revisions.append(revision)
1622
 
 
1623
 
        log_formatter = LogCatcher()
1624
 
        # First request we don't specify number of levels, we should get a
1625
 
        # sensible default (whatever the LogFormatter handles - which in this
1626
 
        # case is 0/everything):
1627
 
        request = log.make_log_request_dict(limit=10)
1628
 
        log.Logger(b, request).show(log_formatter)
1629
 
        # should have all three revisions:
1630
 
        self.assertEquals(len(log_formatter.revisions), 3)
1631
 
 
1632
 
        del log_formatter
1633
 
        log_formatter = LogCatcher()
1634
 
        # now explicitly request mainline revisions only:
1635
 
        request = log.make_log_request_dict(limit=10, levels=1)
1636
 
        log.Logger(b, request).show(log_formatter)
1637
 
        # should now only have 2 revisions:
1638
 
        self.assertEquals(len(log_formatter.revisions), 2)