← 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: Vincent Ladeuil
  • Date: 2009-10-27 14:04:29 UTC
  • mto: (4772.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4773.
  • Revision ID: v.ladeuil+lp@free.fr-20091027140429-br7sqcmk3zstngmm
Fix some typos.

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 TestCaseWithoutPropsHandler(tests.TestCaseWithTransport):
52
31
 
53
32
    def setUp(self):
54
 
        super(TestCaseForLogFormatter, self).setUp()
 
33
        super(TestCaseWithoutPropsHandler, self).setUp()
55
34
        # keep a reference to the "current" custom prop. handler registry
56
35
        self.properties_handler_registry = log.properties_handler_registry
57
36
        # Use a clean registry for log
61
40
            log.properties_handler_registry = self.properties_handler_registry
62
41
        self.addCleanup(restore)
63
42
 
64
 
    def assertFormatterResult(self, result, branch, formatter_class,
65
 
                              formatter_kwargs=None, show_log_kwargs=None):
66
 
        logfile = self.make_utf8_encoded_stringio()
67
 
        if formatter_kwargs is None:
68
 
            formatter_kwargs = {}
69
 
        formatter = formatter_class(to_file=logfile, **formatter_kwargs)
70
 
        if show_log_kwargs is None:
71
 
            show_log_kwargs = {}
72
 
        log.show_log(branch, formatter, **show_log_kwargs)
73
 
        self.assertEqualDiff(result, logfile.getvalue())
74
 
 
75
 
    def make_standard_commit(self, branch_nick, **kwargs):
76
 
        wt = self.make_branch_and_tree('.')
77
 
        wt.lock_write()
78
 
        self.addCleanup(wt.unlock)
79
 
        self.build_tree(['a'])
80
 
        wt.add(['a'])
81
 
        wt.branch.nick = branch_nick
82
 
        kwargs.setdefault('committer', 'Lorem Ipsum <test@example.com>')
83
 
        kwargs.setdefault('authors', ['John Doe <jdoe@example.com>'])
84
 
        self.wt_commit(wt, 'add a', **kwargs)
85
 
        return wt
86
 
 
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
 
    def _prepare_tree_with_merges(self, with_tags=False):
103
 
        wt = self.make_branch_and_memory_tree('.')
104
 
        wt.lock_write()
105
 
        self.addCleanup(wt.unlock)
106
 
        wt.add('')
107
 
        self.wt_commit(wt, 'rev-1', rev_id='rev-1')
108
 
        self.wt_commit(wt, 'rev-merged', rev_id='rev-2a')
109
 
        wt.set_parent_ids(['rev-1', 'rev-2a'])
110
 
        wt.branch.set_last_revision_info(1, 'rev-1')
111
 
        self.wt_commit(wt, 'rev-2', rev_id='rev-2b')
112
 
        if with_tags:
113
 
            branch = wt.branch
114
 
            branch.tags.set_tag('v0.2', 'rev-2b')
115
 
            self.wt_commit(wt, 'rev-3', rev_id='rev-3')
116
 
            branch.tags.set_tag('v1.0rc1', 'rev-3')
117
 
            branch.tags.set_tag('v1.0', 'rev-3')
118
 
        return wt
119
 
 
120
43
 
121
44
class LogCatcher(log.LogFormatter):
122
45
    """Pull log messages into a list rather than displaying them.
126
49
    being dependent on the formatting.
127
50
    """
128
51
 
129
 
    supports_merge_revisions = True
130
52
    supports_delta = True
131
 
    supports_diff = True
132
 
    preferred_levels = 0
133
53
 
134
 
    def __init__(self, *args, **kwargs):
135
 
        kwargs.update(dict(to_file=None))
136
 
        super(LogCatcher, self).__init__(*args, **kwargs)
 
54
    def __init__(self):
 
55
        super(LogCatcher, self).__init__(to_file=None)
137
56
        self.revisions = []
138
57
 
139
58
    def log_revision(self, revision):
282
201
        self.checkDelta(logentry.delta, added=['file1', 'file2'])
283
202
 
284
203
 
285
 
class TestShortLogFormatter(TestCaseForLogFormatter):
 
204
def make_commits_with_trailing_newlines(wt):
 
205
    """Helper method for LogFormatter tests"""
 
206
    b = wt.branch
 
207
    b.nick='test'
 
208
    open('a', 'wb').write('hello moto\n')
 
209
    wt.add('a')
 
210
    wt.commit('simple log message', rev_id='a1',
 
211
              timestamp=1132586655.459960938, timezone=-6*3600,
 
212
              committer='Joe Foo <joe@foo.com>')
 
213
    open('b', 'wb').write('goodbye\n')
 
214
    wt.add('b')
 
215
    wt.commit('multiline\nlog\nmessage\n', rev_id='a2',
 
216
              timestamp=1132586842.411175966, timezone=-6*3600,
 
217
              committer='Joe Foo <joe@foo.com>',
 
218
              authors=['Joe Bar <joe@bar.com>'])
 
219
 
 
220
    open('c', 'wb').write('just another manic monday\n')
 
221
    wt.add('c')
 
222
    wt.commit('single line with trailing newline\n', rev_id='a3',
 
223
              timestamp=1132587176.835228920, timezone=-6*3600,
 
224
              committer = 'Joe Foo <joe@foo.com>')
 
225
    return b
 
226
 
 
227
 
 
228
def normalize_log(log):
 
229
    """Replaces the variable lines of logs with fixed lines"""
 
230
    author = 'author: Dolor Sit <test@example.com>'
 
231
    committer = 'committer: Lorem Ipsum <test@example.com>'
 
232
    lines = log.splitlines(True)
 
233
    for idx,line in enumerate(lines):
 
234
        stripped_line = line.lstrip()
 
235
        indent = ' ' * (len(line) - len(stripped_line))
 
236
        if stripped_line.startswith('author:'):
 
237
            lines[idx] = indent + author + '\n'
 
238
        elif stripped_line.startswith('committer:'):
 
239
            lines[idx] = indent + committer + '\n'
 
240
        elif stripped_line.startswith('timestamp:'):
 
241
            lines[idx] = indent + 'timestamp: Just now\n'
 
242
    return ''.join(lines)
 
243
 
 
244
 
 
245
class TestShortLogFormatter(tests.TestCaseWithTransport):
286
246
 
287
247
    def test_trailing_newlines(self):
288
248
        wt = self.make_branch_and_tree('.')
289
 
        b = self.make_commits_with_trailing_newlines(wt)
290
 
        self.assertFormatterResult("""\
291
 
    3 Joe Foo\t2005-11-22
 
249
        b = make_commits_with_trailing_newlines(wt)
 
250
        sio = self.make_utf8_encoded_stringio()
 
251
        lf = log.ShortLogFormatter(to_file=sio)
 
252
        log.show_log(b, lf)
 
253
        self.assertEqualDiff("""\
 
254
    3 Joe Foo\t2005-11-21
292
255
      single line with trailing newline
293
256
 
294
 
    2 Joe Foo\t2005-11-22
 
257
    2 Joe Bar\t2005-11-21
295
258
      multiline
296
259
      log
297
260
      message
298
261
 
299
 
    1 Joe Foo\t2005-11-22
 
262
    1 Joe Foo\t2005-11-21
300
263
      simple log message
301
264
 
302
265
""",
303
 
            b, log.ShortLogFormatter)
 
266
                             sio.getvalue())
 
267
 
 
268
    def _prepare_tree_with_merges(self, with_tags=False):
 
269
        wt = self.make_branch_and_memory_tree('.')
 
270
        wt.lock_write()
 
271
        self.addCleanup(wt.unlock)
 
272
        wt.add('')
 
273
        wt.commit('rev-1', rev_id='rev-1',
 
274
                  timestamp=1132586655, timezone=36000,
 
275
                  committer='Joe Foo <joe@foo.com>')
 
276
        wt.commit('rev-merged', rev_id='rev-2a',
 
277
                  timestamp=1132586700, timezone=36000,
 
278
                  committer='Joe Foo <joe@foo.com>')
 
279
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
280
        wt.branch.set_last_revision_info(1, 'rev-1')
 
281
        wt.commit('rev-2', rev_id='rev-2b',
 
282
                  timestamp=1132586800, timezone=36000,
 
283
                  committer='Joe Foo <joe@foo.com>')
 
284
        if with_tags:
 
285
            branch = wt.branch
 
286
            branch.tags.set_tag('v0.2', 'rev-2b')
 
287
            wt.commit('rev-3', rev_id='rev-3',
 
288
                      timestamp=1132586900, timezone=36000,
 
289
                      committer='Jane Foo <jane@foo.com>')
 
290
            branch.tags.set_tag('v1.0rc1', 'rev-3')
 
291
            branch.tags.set_tag('v1.0', 'rev-3')
 
292
        return wt
304
293
 
305
294
    def test_short_log_with_merges(self):
306
295
        wt = self._prepare_tree_with_merges()
307
 
        self.assertFormatterResult("""\
 
296
        logfile = self.make_utf8_encoded_stringio()
 
297
        formatter = log.ShortLogFormatter(to_file=logfile)
 
298
        log.show_log(wt.branch, formatter)
 
299
        self.assertEqualDiff("""\
308
300
    2 Joe Foo\t2005-11-22 [merge]
309
301
      rev-2
310
302
 
312
304
      rev-1
313
305
 
314
306
""",
315
 
            wt.branch, log.ShortLogFormatter)
 
307
                             logfile.getvalue())
316
308
 
317
309
    def test_short_log_with_merges_and_advice(self):
318
310
        wt = self._prepare_tree_with_merges()
319
 
        self.assertFormatterResult("""\
 
311
        logfile = self.make_utf8_encoded_stringio()
 
312
        formatter = log.ShortLogFormatter(to_file=logfile,
 
313
            show_advice=True)
 
314
        log.show_log(wt.branch, formatter)
 
315
        self.assertEqualDiff("""\
320
316
    2 Joe Foo\t2005-11-22 [merge]
321
317
      rev-2
322
318
 
325
321
 
326
322
Use --include-merges or -n0 to see merged revisions.
327
323
""",
328
 
            wt.branch, log.ShortLogFormatter,
329
 
            formatter_kwargs=dict(show_advice=True))
 
324
                             logfile.getvalue())
330
325
 
331
326
    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')
 
327
        wt = self.make_branch_and_memory_tree('.')
 
328
        wt.lock_write()
 
329
        self.addCleanup(wt.unlock)
 
330
        wt.add('')
 
331
        wt.commit('rev-1', rev_id='rev-1',
 
332
                  timestamp=1132586655, timezone=36000,
 
333
                  committer='Joe Foo <joe@foo.com>')
 
334
        wt.commit('rev-merged', rev_id='rev-2a',
 
335
                  timestamp=1132586700, timezone=36000,
 
336
                  committer='Joe Foo <joe@foo.com>')
 
337
        wt.branch.set_last_revision_info(1, 'rev-1')
 
338
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
339
        wt.commit('rev-2b', rev_id='rev-2b',
 
340
                  timestamp=1132586800, timezone=36000,
 
341
                  committer='Joe Foo <joe@foo.com>')
 
342
        wt.commit('rev-3a', rev_id='rev-3a',
 
343
                  timestamp=1132586800, timezone=36000,
 
344
                  committer='Joe Foo <joe@foo.com>')
334
345
        wt.branch.set_last_revision_info(2, 'rev-2b')
335
346
        wt.set_parent_ids(['rev-2b', 'rev-3a'])
336
 
        self.wt_commit(wt, 'rev-3b', rev_id='rev-3b')
337
 
        self.assertFormatterResult("""\
 
347
        wt.commit('rev-3b', rev_id='rev-3b',
 
348
                  timestamp=1132586800, timezone=36000,
 
349
                  committer='Joe Foo <joe@foo.com>')
 
350
        logfile = self.make_utf8_encoded_stringio()
 
351
        formatter = log.ShortLogFormatter(to_file=logfile)
 
352
        log.show_log(wt.branch, formatter,
 
353
            start_revision=2, end_revision=3)
 
354
        self.assertEqualDiff("""\
338
355
    3 Joe Foo\t2005-11-22 [merge]
339
356
      rev-3b
340
357
 
341
358
    2 Joe Foo\t2005-11-22 [merge]
342
 
      rev-2
 
359
      rev-2b
343
360
 
344
361
""",
345
 
            wt.branch, log.ShortLogFormatter,
346
 
            show_log_kwargs=dict(start_revision=2, end_revision=3))
 
362
                             logfile.getvalue())
347
363
 
348
364
    def test_short_log_with_tags(self):
349
365
        wt = self._prepare_tree_with_merges(with_tags=True)
350
 
        self.assertFormatterResult("""\
351
 
    3 Joe Foo\t2005-11-22 {v1.0, v1.0rc1}
 
366
        logfile = self.make_utf8_encoded_stringio()
 
367
        formatter = log.ShortLogFormatter(to_file=logfile)
 
368
        log.show_log(wt.branch, formatter)
 
369
        self.assertEqualDiff("""\
 
370
    3 Jane Foo\t2005-11-22 {v1.0, v1.0rc1}
352
371
      rev-3
353
372
 
354
373
    2 Joe Foo\t2005-11-22 {v0.2} [merge]
358
377
      rev-1
359
378
 
360
379
""",
361
 
            wt.branch, log.ShortLogFormatter)
 
380
                             logfile.getvalue())
362
381
 
363
382
    def test_short_log_single_merge_revision(self):
364
 
        wt = self._prepare_tree_with_merges()
 
383
        wt = self.make_branch_and_memory_tree('.')
 
384
        wt.lock_write()
 
385
        self.addCleanup(wt.unlock)
 
386
        wt.add('')
 
387
        wt.commit('rev-1', rev_id='rev-1',
 
388
                  timestamp=1132586655, timezone=36000,
 
389
                  committer='Joe Foo <joe@foo.com>')
 
390
        wt.commit('rev-merged', rev_id='rev-2a',
 
391
                  timestamp=1132586700, timezone=36000,
 
392
                  committer='Joe Foo <joe@foo.com>')
 
393
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
394
        wt.branch.set_last_revision_info(1, 'rev-1')
 
395
        wt.commit('rev-2', rev_id='rev-2b',
 
396
                  timestamp=1132586800, timezone=36000,
 
397
                  committer='Joe Foo <joe@foo.com>')
 
398
        logfile = self.make_utf8_encoded_stringio()
 
399
        formatter = log.ShortLogFormatter(to_file=logfile)
365
400
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
366
 
        rev = revspec.in_history(wt.branch)
367
 
        self.assertFormatterResult("""\
 
401
        wtb = wt.branch
 
402
        rev = revspec.in_history(wtb)
 
403
        log.show_log(wtb, formatter, start_revision=rev, end_revision=rev)
 
404
        self.assertEqualDiff("""\
368
405
      1.1.1 Joe Foo\t2005-11-22
369
406
            rev-merged
370
407
 
371
408
""",
372
 
            wt.branch, log.ShortLogFormatter,
373
 
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
374
 
 
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
 
 
402
 
class TestShortLogFormatterWithMergeRevisions(TestCaseForLogFormatter):
 
409
                             logfile.getvalue())
 
410
 
 
411
 
 
412
class TestShortLogFormatterWithMergeRevisions(tests.TestCaseWithTransport):
403
413
 
404
414
    def test_short_merge_revs_log_with_merges(self):
405
 
        wt = self._prepare_tree_with_merges()
 
415
        wt = self.make_branch_and_memory_tree('.')
 
416
        wt.lock_write()
 
417
        self.addCleanup(wt.unlock)
 
418
        wt.add('')
 
419
        wt.commit('rev-1', rev_id='rev-1',
 
420
                  timestamp=1132586655, timezone=36000,
 
421
                  committer='Joe Foo <joe@foo.com>')
 
422
        wt.commit('rev-merged', rev_id='rev-2a',
 
423
                  timestamp=1132586700, timezone=36000,
 
424
                  committer='Joe Foo <joe@foo.com>')
 
425
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
426
        wt.branch.set_last_revision_info(1, 'rev-1')
 
427
        wt.commit('rev-2', rev_id='rev-2b',
 
428
                  timestamp=1132586800, timezone=36000,
 
429
                  committer='Joe Foo <joe@foo.com>')
 
430
        logfile = self.make_utf8_encoded_stringio()
 
431
        formatter = log.ShortLogFormatter(to_file=logfile, levels=0)
 
432
        log.show_log(wt.branch, formatter)
406
433
        # Note that the 1.1.1 indenting is in fact correct given that
407
434
        # the revision numbers are right justified within 5 characters
408
435
        # for mainline revnos and 9 characters for dotted revnos.
409
 
        self.assertFormatterResult("""\
 
436
        self.assertEqualDiff("""\
410
437
    2 Joe Foo\t2005-11-22 [merge]
411
438
      rev-2
412
439
 
417
444
      rev-1
418
445
 
419
446
""",
420
 
            wt.branch, log.ShortLogFormatter,
421
 
            formatter_kwargs=dict(levels=0))
 
447
                             logfile.getvalue())
422
448
 
423
449
    def test_short_merge_revs_log_single_merge_revision(self):
424
 
        wt = self._prepare_tree_with_merges()
 
450
        wt = self.make_branch_and_memory_tree('.')
 
451
        wt.lock_write()
 
452
        self.addCleanup(wt.unlock)
 
453
        wt.add('')
 
454
        wt.commit('rev-1', rev_id='rev-1',
 
455
                  timestamp=1132586655, timezone=36000,
 
456
                  committer='Joe Foo <joe@foo.com>')
 
457
        wt.commit('rev-merged', rev_id='rev-2a',
 
458
                  timestamp=1132586700, timezone=36000,
 
459
                  committer='Joe Foo <joe@foo.com>')
 
460
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
461
        wt.branch.set_last_revision_info(1, 'rev-1')
 
462
        wt.commit('rev-2', rev_id='rev-2b',
 
463
                  timestamp=1132586800, timezone=36000,
 
464
                  committer='Joe Foo <joe@foo.com>')
 
465
        logfile = self.make_utf8_encoded_stringio()
 
466
        formatter = log.ShortLogFormatter(to_file=logfile, levels=0)
425
467
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
426
 
        rev = revspec.in_history(wt.branch)
427
 
        self.assertFormatterResult("""\
 
468
        wtb = wt.branch
 
469
        rev = revspec.in_history(wtb)
 
470
        log.show_log(wtb, formatter, start_revision=rev, end_revision=rev)
 
471
        self.assertEqualDiff("""\
428
472
      1.1.1 Joe Foo\t2005-11-22
429
473
            rev-merged
430
474
 
431
475
""",
432
 
            wt.branch, log.ShortLogFormatter,
433
 
            formatter_kwargs=dict(levels=0),
434
 
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
435
 
 
436
 
 
437
 
class TestLongLogFormatter(TestCaseForLogFormatter):
 
476
                             logfile.getvalue())
 
477
 
 
478
 
 
479
class TestLongLogFormatter(TestCaseWithoutPropsHandler):
438
480
 
439
481
    def test_verbose_log(self):
440
482
        """Verbose log includes changed files
441
483
 
442
484
        bug #4676
443
485
        """
444
 
        wt = self.make_standard_commit('test_verbose_log', authors=[])
445
 
        self.assertFormatterResult('''\
 
486
        wt = self.make_branch_and_tree('.')
 
487
        b = wt.branch
 
488
        self.build_tree(['a'])
 
489
        wt.add('a')
 
490
        # XXX: why does a longer nick show up?
 
491
        b.nick = 'test_verbose_log'
 
492
        wt.commit(message='add a',
 
493
                  timestamp=1132711707,
 
494
                  timezone=36000,
 
495
                  committer='Lorem Ipsum <test@example.com>')
 
496
        logfile = file('out.tmp', 'w+')
 
497
        formatter = log.LongLogFormatter(to_file=logfile)
 
498
        log.show_log(b, formatter, verbose=True)
 
499
        logfile.flush()
 
500
        logfile.seek(0)
 
501
        log_contents = logfile.read()
 
502
        self.assertEqualDiff('''\
446
503
------------------------------------------------------------
447
504
revno: 1
448
505
committer: Lorem Ipsum <test@example.com>
449
506
branch nick: test_verbose_log
450
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
507
timestamp: Wed 2005-11-23 12:08:27 +1000
451
508
message:
452
509
  add a
453
510
added:
454
511
  a
455
512
''',
456
 
            wt.branch, log.LongLogFormatter,
457
 
            show_log_kwargs=dict(verbose=True))
 
513
                             log_contents)
458
514
 
459
515
    def test_merges_are_indented_by_level(self):
460
516
        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')
470
 
        self.assertFormatterResult("""\
 
517
        wt.commit('first post')
 
518
        self.run_bzr('branch parent child')
 
519
        self.run_bzr(['commit', '-m', 'branch 1', '--unchanged', 'child'])
 
520
        self.run_bzr('branch child smallerchild')
 
521
        self.run_bzr(['commit', '-m', 'branch 2', '--unchanged',
 
522
            'smallerchild'])
 
523
        os.chdir('child')
 
524
        self.run_bzr('merge ../smallerchild')
 
525
        self.run_bzr(['commit', '-m', 'merge branch 2'])
 
526
        os.chdir('../parent')
 
527
        self.run_bzr('merge ../child')
 
528
        wt.commit('merge branch 1')
 
529
        b = wt.branch
 
530
        sio = self.make_utf8_encoded_stringio()
 
531
        lf = log.LongLogFormatter(to_file=sio, levels=0)
 
532
        log.show_log(b, lf, verbose=True)
 
533
        the_log = normalize_log(sio.getvalue())
 
534
        self.assertEqualDiff("""\
471
535
------------------------------------------------------------
472
536
revno: 2 [merge]
473
 
committer: Joe Foo <joe@foo.com>
 
537
committer: Lorem Ipsum <test@example.com>
474
538
branch nick: parent
475
 
timestamp: Tue 2005-11-22 00:00:04 +0000
 
539
timestamp: Just now
476
540
message:
477
541
  merge branch 1
478
542
    ------------------------------------------------------------
479
543
    revno: 1.1.2 [merge]
480
 
    committer: Joe Foo <joe@foo.com>
 
544
    committer: Lorem Ipsum <test@example.com>
481
545
    branch nick: child
482
 
    timestamp: Tue 2005-11-22 00:00:03 +0000
 
546
    timestamp: Just now
483
547
    message:
484
548
      merge branch 2
485
549
        ------------------------------------------------------------
486
550
        revno: 1.2.1
487
 
        committer: Joe Foo <joe@foo.com>
 
551
        committer: Lorem Ipsum <test@example.com>
488
552
        branch nick: smallerchild
489
 
        timestamp: Tue 2005-11-22 00:00:02 +0000
 
553
        timestamp: Just now
490
554
        message:
491
555
          branch 2
492
556
    ------------------------------------------------------------
493
557
    revno: 1.1.1
494
 
    committer: Joe Foo <joe@foo.com>
 
558
    committer: Lorem Ipsum <test@example.com>
495
559
    branch nick: child
496
 
    timestamp: Tue 2005-11-22 00:00:01 +0000
 
560
    timestamp: Just now
497
561
    message:
498
562
      branch 1
499
563
------------------------------------------------------------
500
564
revno: 1
501
 
committer: Joe Foo <joe@foo.com>
 
565
committer: Lorem Ipsum <test@example.com>
502
566
branch nick: parent
503
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
567
timestamp: Just now
504
568
message:
505
569
  first post
506
570
""",
507
 
            wt.branch, log.LongLogFormatter,
508
 
            formatter_kwargs=dict(levels=0),
509
 
            show_log_kwargs=dict(verbose=True))
 
571
                             the_log)
510
572
 
511
573
    def test_verbose_merge_revisions_contain_deltas(self):
512
574
        wt = self.make_branch_and_tree('parent')
513
575
        self.build_tree(['parent/f1', 'parent/f2'])
514
576
        wt.add(['f1','f2'])
515
 
        self.wt_commit(wt, 'first post')
516
 
        child_wt = wt.bzrdir.sprout('child').open_workingtree()
 
577
        wt.commit('first post')
 
578
        self.run_bzr('branch parent child')
517
579
        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')
522
 
        self.assertFormatterResult("""\
 
580
        file('child/f2', 'wb').write('hello\n')
 
581
        self.run_bzr(['commit', '-m', 'removed f1 and modified f2',
 
582
            'child'])
 
583
        os.chdir('parent')
 
584
        self.run_bzr('merge ../child')
 
585
        wt.commit('merge branch 1')
 
586
        b = wt.branch
 
587
        sio = self.make_utf8_encoded_stringio()
 
588
        lf = log.LongLogFormatter(to_file=sio, levels=0)
 
589
        log.show_log(b, lf, verbose=True)
 
590
        the_log = normalize_log(sio.getvalue())
 
591
        self.assertEqualDiff("""\
523
592
------------------------------------------------------------
524
593
revno: 2 [merge]
525
 
committer: Joe Foo <joe@foo.com>
 
594
committer: Lorem Ipsum <test@example.com>
526
595
branch nick: parent
527
 
timestamp: Tue 2005-11-22 00:00:02 +0000
 
596
timestamp: Just now
528
597
message:
529
598
  merge branch 1
530
599
removed:
533
602
  f2
534
603
    ------------------------------------------------------------
535
604
    revno: 1.1.1
536
 
    committer: Joe Foo <joe@foo.com>
 
605
    committer: Lorem Ipsum <test@example.com>
537
606
    branch nick: child
538
 
    timestamp: Tue 2005-11-22 00:00:01 +0000
 
607
    timestamp: Just now
539
608
    message:
540
609
      removed f1 and modified f2
541
610
    removed:
544
613
      f2
545
614
------------------------------------------------------------
546
615
revno: 1
547
 
committer: Joe Foo <joe@foo.com>
 
616
committer: Lorem Ipsum <test@example.com>
548
617
branch nick: parent
549
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
618
timestamp: Just now
550
619
message:
551
620
  first post
552
621
added:
553
622
  f1
554
623
  f2
555
624
""",
556
 
            wt.branch, log.LongLogFormatter,
557
 
            formatter_kwargs=dict(levels=0),
558
 
            show_log_kwargs=dict(verbose=True))
 
625
                             the_log)
559
626
 
560
627
    def test_trailing_newlines(self):
561
628
        wt = self.make_branch_and_tree('.')
562
 
        b = self.make_commits_with_trailing_newlines(wt)
563
 
        self.assertFormatterResult("""\
 
629
        b = make_commits_with_trailing_newlines(wt)
 
630
        sio = self.make_utf8_encoded_stringio()
 
631
        lf = log.LongLogFormatter(to_file=sio)
 
632
        log.show_log(b, lf)
 
633
        self.assertEqualDiff("""\
564
634
------------------------------------------------------------
565
635
revno: 3
566
636
committer: Joe Foo <joe@foo.com>
567
637
branch nick: test
568
 
timestamp: Tue 2005-11-22 00:00:02 +0000
 
638
timestamp: Mon 2005-11-21 09:32:56 -0600
569
639
message:
570
640
  single line with trailing newline
571
641
------------------------------------------------------------
572
642
revno: 2
 
643
author: Joe Bar <joe@bar.com>
573
644
committer: Joe Foo <joe@foo.com>
574
645
branch nick: test
575
 
timestamp: Tue 2005-11-22 00:00:01 +0000
 
646
timestamp: Mon 2005-11-21 09:27:22 -0600
576
647
message:
577
648
  multiline
578
649
  log
581
652
revno: 1
582
653
committer: Joe Foo <joe@foo.com>
583
654
branch nick: test
584
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
655
timestamp: Mon 2005-11-21 09:24:15 -0600
585
656
message:
586
657
  simple log message
587
658
""",
588
 
        b, log.LongLogFormatter)
 
659
                             sio.getvalue())
589
660
 
590
661
    def test_author_in_log(self):
591
662
        """Log includes the author name if it's set in
592
663
        the revision properties
593
664
        """
594
 
        wt = self.make_standard_commit('test_author_log',
595
 
            authors=['John Doe <jdoe@example.com>',
596
 
                     'Jane Rey <jrey@example.com>'])
597
 
        self.assertFormatterResult("""\
 
665
        wt = self.make_branch_and_tree('.')
 
666
        b = wt.branch
 
667
        self.build_tree(['a'])
 
668
        wt.add('a')
 
669
        b.nick = 'test_author_log'
 
670
        wt.commit(message='add a',
 
671
                  timestamp=1132711707,
 
672
                  timezone=36000,
 
673
                  committer='Lorem Ipsum <test@example.com>',
 
674
                  authors=['John Doe <jdoe@example.com>',
 
675
                           'Jane Rey <jrey@example.com>'])
 
676
        sio = StringIO()
 
677
        formatter = log.LongLogFormatter(to_file=sio)
 
678
        log.show_log(b, formatter)
 
679
        self.assertEqualDiff('''\
598
680
------------------------------------------------------------
599
681
revno: 1
600
682
author: John Doe <jdoe@example.com>, Jane Rey <jrey@example.com>
601
683
committer: Lorem Ipsum <test@example.com>
602
684
branch nick: test_author_log
603
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
685
timestamp: Wed 2005-11-23 12:08:27 +1000
604
686
message:
605
687
  add a
606
 
""",
607
 
        wt.branch, log.LongLogFormatter)
 
688
''',
 
689
                             sio.getvalue())
608
690
 
609
691
    def test_properties_in_log(self):
610
692
        """Log includes the custom properties returned by the registered
611
693
        handlers.
612
694
        """
613
 
        wt = self.make_standard_commit('test_properties_in_log')
614
 
        def trivial_custom_prop_handler(revision):
615
 
            return {'test_prop':'test_value'}
 
695
        wt = self.make_branch_and_tree('.')
 
696
        b = wt.branch
 
697
        self.build_tree(['a'])
 
698
        wt.add('a')
 
699
        b.nick = 'test_properties_in_log'
 
700
        wt.commit(message='add a',
 
701
                  timestamp=1132711707,
 
702
                  timezone=36000,
 
703
                  committer='Lorem Ipsum <test@example.com>',
 
704
                  authors=['John Doe <jdoe@example.com>'])
 
705
        sio = StringIO()
 
706
        formatter = log.LongLogFormatter(to_file=sio)
 
707
        try:
 
708
            def trivial_custom_prop_handler(revision):
 
709
                return {'test_prop':'test_value'}
616
710
 
617
 
        # Cleaned up in setUp()
618
 
        log.properties_handler_registry.register(
619
 
            'trivial_custom_prop_handler',
620
 
            trivial_custom_prop_handler)
621
 
        self.assertFormatterResult("""\
 
711
            log.properties_handler_registry.register(
 
712
                'trivial_custom_prop_handler',
 
713
                trivial_custom_prop_handler)
 
714
            log.show_log(b, formatter)
 
715
        finally:
 
716
            log.properties_handler_registry.remove(
 
717
                'trivial_custom_prop_handler')
 
718
            self.assertEqualDiff('''\
622
719
------------------------------------------------------------
623
720
revno: 1
624
721
test_prop: test_value
625
722
author: John Doe <jdoe@example.com>
626
723
committer: Lorem Ipsum <test@example.com>
627
724
branch nick: test_properties_in_log
628
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
725
timestamp: Wed 2005-11-23 12:08:27 +1000
629
726
message:
630
727
  add a
631
 
""",
632
 
            wt.branch, log.LongLogFormatter)
 
728
''',
 
729
                                 sio.getvalue())
633
730
 
634
731
    def test_properties_in_short_log(self):
635
732
        """Log includes the custom properties returned by the registered
636
733
        handlers.
637
734
        """
638
 
        wt = self.make_standard_commit('test_properties_in_short_log')
639
 
        def trivial_custom_prop_handler(revision):
640
 
            return {'test_prop':'test_value'}
 
735
        wt = self.make_branch_and_tree('.')
 
736
        b = wt.branch
 
737
        self.build_tree(['a'])
 
738
        wt.add('a')
 
739
        b.nick = 'test_properties_in_short_log'
 
740
        wt.commit(message='add a',
 
741
                  timestamp=1132711707,
 
742
                  timezone=36000,
 
743
                  committer='Lorem Ipsum <test@example.com>',
 
744
                  authors=['John Doe <jdoe@example.com>'])
 
745
        sio = StringIO()
 
746
        formatter = log.ShortLogFormatter(to_file=sio)
 
747
        try:
 
748
            def trivial_custom_prop_handler(revision):
 
749
                return {'test_prop':'test_value'}
641
750
 
642
 
        log.properties_handler_registry.register(
643
 
            'trivial_custom_prop_handler',
644
 
            trivial_custom_prop_handler)
645
 
        self.assertFormatterResult("""\
646
 
    1 John Doe\t2005-11-22
 
751
            log.properties_handler_registry.register(
 
752
                'trivial_custom_prop_handler',
 
753
                trivial_custom_prop_handler)
 
754
            log.show_log(b, formatter)
 
755
        finally:
 
756
            log.properties_handler_registry.remove(
 
757
                'trivial_custom_prop_handler')
 
758
            self.assertEqualDiff('''\
 
759
    1 John Doe\t2005-11-23
647
760
      test_prop: test_value
648
761
      add a
649
762
 
650
 
""",
651
 
            wt.branch, log.ShortLogFormatter)
 
763
''',
 
764
                                 sio.getvalue())
652
765
 
653
766
    def test_error_in_properties_handler(self):
654
767
        """Log includes the custom properties returned by the registered
655
768
        handlers.
656
769
        """
657
 
        wt = self.make_standard_commit('error_in_properties_handler',
658
 
            revprops={'first_prop':'first_value'})
659
 
        sio = self.make_utf8_encoded_stringio()
 
770
        wt = self.make_branch_and_tree('.')
 
771
        b = wt.branch
 
772
        self.build_tree(['a'])
 
773
        wt.add('a')
 
774
        b.nick = 'test_author_log'
 
775
        wt.commit(message='add a',
 
776
                  timestamp=1132711707,
 
777
                  timezone=36000,
 
778
                  committer='Lorem Ipsum <test@example.com>',
 
779
                  authors=['John Doe <jdoe@example.com>'],
 
780
                  revprops={'first_prop':'first_value'})
 
781
        sio = StringIO()
660
782
        formatter = log.LongLogFormatter(to_file=sio)
661
 
        def trivial_custom_prop_handler(revision):
662
 
            raise StandardError("a test error")
 
783
        try:
 
784
            def trivial_custom_prop_handler(revision):
 
785
                raise StandardError("a test error")
663
786
 
664
 
        log.properties_handler_registry.register(
665
 
            'trivial_custom_prop_handler',
666
 
            trivial_custom_prop_handler)
667
 
        self.assertRaises(StandardError, log.show_log, wt.branch, formatter,)
 
787
            log.properties_handler_registry.register(
 
788
                'trivial_custom_prop_handler',
 
789
                trivial_custom_prop_handler)
 
790
            self.assertRaises(StandardError, log.show_log, b, formatter,)
 
791
        finally:
 
792
            log.properties_handler_registry.remove(
 
793
                'trivial_custom_prop_handler')
668
794
 
669
795
    def test_properties_handler_bad_argument(self):
670
 
        wt = self.make_standard_commit('bad_argument',
671
 
              revprops={'a_prop':'test_value'})
672
 
        sio = self.make_utf8_encoded_stringio()
 
796
        wt = self.make_branch_and_tree('.')
 
797
        b = wt.branch
 
798
        self.build_tree(['a'])
 
799
        wt.add('a')
 
800
        b.nick = 'test_author_log'
 
801
        wt.commit(message='add a',
 
802
                  timestamp=1132711707,
 
803
                  timezone=36000,
 
804
                  committer='Lorem Ipsum <test@example.com>',
 
805
                  authors=['John Doe <jdoe@example.com>'],
 
806
                  revprops={'a_prop':'test_value'})
 
807
        sio = StringIO()
673
808
        formatter = log.LongLogFormatter(to_file=sio)
674
 
        def bad_argument_prop_handler(revision):
675
 
            return {'custom_prop_name':revision.properties['a_prop']}
676
 
 
677
 
        log.properties_handler_registry.register(
678
 
            'bad_argument_prop_handler',
679
 
            bad_argument_prop_handler)
680
 
 
681
 
        self.assertRaises(AttributeError, formatter.show_properties,
682
 
                          'a revision', '')
683
 
 
684
 
        revision = wt.branch.repository.get_revision(wt.branch.last_revision())
685
 
        formatter.show_properties(revision, '')
686
 
        self.assertEqualDiff('''custom_prop_name: test_value\n''',
687
 
                             sio.getvalue())
688
 
 
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
 
 
731
 
class TestLongLogFormatterWithoutMergeRevisions(TestCaseForLogFormatter):
 
809
        try:
 
810
            def bad_argument_prop_handler(revision):
 
811
                return {'custom_prop_name':revision.properties['a_prop']}
 
812
 
 
813
            log.properties_handler_registry.register(
 
814
                'bad_argument_prop_handler',
 
815
                bad_argument_prop_handler)
 
816
 
 
817
            self.assertRaises(AttributeError, formatter.show_properties,
 
818
                              'a revision', '')
 
819
 
 
820
            revision = b.repository.get_revision(b.last_revision())
 
821
            formatter.show_properties(revision, '')
 
822
            self.assertEqualDiff('''custom_prop_name: test_value\n''',
 
823
                                 sio.getvalue())
 
824
        finally:
 
825
            log.properties_handler_registry.remove(
 
826
                'bad_argument_prop_handler')
 
827
 
 
828
 
 
829
class TestLongLogFormatterWithoutMergeRevisions(TestCaseWithoutPropsHandler):
732
830
 
733
831
    def test_long_verbose_log(self):
734
832
        """Verbose log includes changed files
735
833
 
736
834
        bug #4676
737
835
        """
738
 
        wt = self.make_standard_commit('test_long_verbose_log', authors=[])
739
 
        self.assertFormatterResult("""\
 
836
        wt = self.make_branch_and_tree('.')
 
837
        b = wt.branch
 
838
        self.build_tree(['a'])
 
839
        wt.add('a')
 
840
        # XXX: why does a longer nick show up?
 
841
        b.nick = 'test_verbose_log'
 
842
        wt.commit(message='add a',
 
843
                  timestamp=1132711707,
 
844
                  timezone=36000,
 
845
                  committer='Lorem Ipsum <test@example.com>')
 
846
        logfile = file('out.tmp', 'w+')
 
847
        formatter = log.LongLogFormatter(to_file=logfile, levels=1)
 
848
        log.show_log(b, formatter, verbose=True)
 
849
        logfile.flush()
 
850
        logfile.seek(0)
 
851
        log_contents = logfile.read()
 
852
        self.assertEqualDiff('''\
740
853
------------------------------------------------------------
741
854
revno: 1
742
855
committer: Lorem Ipsum <test@example.com>
743
 
branch nick: test_long_verbose_log
744
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
856
branch nick: test_verbose_log
 
857
timestamp: Wed 2005-11-23 12:08:27 +1000
745
858
message:
746
859
  add a
747
860
added:
748
861
  a
749
 
""",
750
 
            wt.branch, log.LongLogFormatter,
751
 
            formatter_kwargs=dict(levels=1),
752
 
            show_log_kwargs=dict(verbose=True))
 
862
''',
 
863
                             log_contents)
753
864
 
754
865
    def test_long_verbose_contain_deltas(self):
755
866
        wt = self.make_branch_and_tree('parent')
756
867
        self.build_tree(['parent/f1', 'parent/f2'])
757
868
        wt.add(['f1','f2'])
758
 
        self.wt_commit(wt, 'first post')
759
 
        child_wt = wt.bzrdir.sprout('child').open_workingtree()
 
869
        wt.commit('first post')
 
870
        self.run_bzr('branch parent child')
760
871
        os.unlink('child/f1')
761
 
        self.build_tree_contents([('child/f2', 'hello\n')])
762
 
        self.wt_commit(child_wt, 'removed f1 and modified f2')
763
 
        wt.merge_from_branch(child_wt.branch)
764
 
        self.wt_commit(wt, 'merge branch 1')
765
 
        self.assertFormatterResult("""\
 
872
        file('child/f2', 'wb').write('hello\n')
 
873
        self.run_bzr(['commit', '-m', 'removed f1 and modified f2',
 
874
            'child'])
 
875
        os.chdir('parent')
 
876
        self.run_bzr('merge ../child')
 
877
        wt.commit('merge branch 1')
 
878
        b = wt.branch
 
879
        sio = self.make_utf8_encoded_stringio()
 
880
        lf = log.LongLogFormatter(to_file=sio, levels=1)
 
881
        log.show_log(b, lf, verbose=True)
 
882
        the_log = normalize_log(sio.getvalue())
 
883
        self.assertEqualDiff("""\
766
884
------------------------------------------------------------
767
885
revno: 2 [merge]
768
 
committer: Joe Foo <joe@foo.com>
 
886
committer: Lorem Ipsum <test@example.com>
769
887
branch nick: parent
770
 
timestamp: Tue 2005-11-22 00:00:02 +0000
 
888
timestamp: Just now
771
889
message:
772
890
  merge branch 1
773
891
removed:
776
894
  f2
777
895
------------------------------------------------------------
778
896
revno: 1
779
 
committer: Joe Foo <joe@foo.com>
 
897
committer: Lorem Ipsum <test@example.com>
780
898
branch nick: parent
781
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
899
timestamp: Just now
782
900
message:
783
901
  first post
784
902
added:
785
903
  f1
786
904
  f2
787
905
""",
788
 
            wt.branch, log.LongLogFormatter,
789
 
            formatter_kwargs=dict(levels=1),
790
 
            show_log_kwargs=dict(verbose=True))
 
906
                             the_log)
791
907
 
792
908
    def test_long_trailing_newlines(self):
793
909
        wt = self.make_branch_and_tree('.')
794
 
        b = self.make_commits_with_trailing_newlines(wt)
795
 
        self.assertFormatterResult("""\
 
910
        b = make_commits_with_trailing_newlines(wt)
 
911
        sio = self.make_utf8_encoded_stringio()
 
912
        lf = log.LongLogFormatter(to_file=sio, levels=1)
 
913
        log.show_log(b, lf)
 
914
        self.assertEqualDiff("""\
796
915
------------------------------------------------------------
797
916
revno: 3
798
917
committer: Joe Foo <joe@foo.com>
799
918
branch nick: test
800
 
timestamp: Tue 2005-11-22 00:00:02 +0000
 
919
timestamp: Mon 2005-11-21 09:32:56 -0600
801
920
message:
802
921
  single line with trailing newline
803
922
------------------------------------------------------------
804
923
revno: 2
 
924
author: Joe Bar <joe@bar.com>
805
925
committer: Joe Foo <joe@foo.com>
806
926
branch nick: test
807
 
timestamp: Tue 2005-11-22 00:00:01 +0000
 
927
timestamp: Mon 2005-11-21 09:27:22 -0600
808
928
message:
809
929
  multiline
810
930
  log
813
933
revno: 1
814
934
committer: Joe Foo <joe@foo.com>
815
935
branch nick: test
816
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
936
timestamp: Mon 2005-11-21 09:24:15 -0600
817
937
message:
818
938
  simple log message
819
939
""",
820
 
        b, log.LongLogFormatter,
821
 
        formatter_kwargs=dict(levels=1))
 
940
                             sio.getvalue())
822
941
 
823
942
    def test_long_author_in_log(self):
824
943
        """Log includes the author name if it's set in
825
944
        the revision properties
826
945
        """
827
 
        wt = self.make_standard_commit('test_author_log')
828
 
        self.assertFormatterResult("""\
 
946
        wt = self.make_branch_and_tree('.')
 
947
        b = wt.branch
 
948
        self.build_tree(['a'])
 
949
        wt.add('a')
 
950
        b.nick = 'test_author_log'
 
951
        wt.commit(message='add a',
 
952
                  timestamp=1132711707,
 
953
                  timezone=36000,
 
954
                  committer='Lorem Ipsum <test@example.com>',
 
955
                  authors=['John Doe <jdoe@example.com>'])
 
956
        sio = StringIO()
 
957
        formatter = log.LongLogFormatter(to_file=sio, levels=1)
 
958
        log.show_log(b, formatter)
 
959
        self.assertEqualDiff('''\
829
960
------------------------------------------------------------
830
961
revno: 1
831
962
author: John Doe <jdoe@example.com>
832
963
committer: Lorem Ipsum <test@example.com>
833
964
branch nick: test_author_log
834
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
965
timestamp: Wed 2005-11-23 12:08:27 +1000
835
966
message:
836
967
  add a
837
 
""",
838
 
            wt.branch, log.LongLogFormatter,
839
 
            formatter_kwargs=dict(levels=1))
 
968
''',
 
969
                             sio.getvalue())
840
970
 
841
971
    def test_long_properties_in_log(self):
842
972
        """Log includes the custom properties returned by the registered
843
973
        handlers.
844
974
        """
845
 
        wt = self.make_standard_commit('test_properties_in_log')
846
 
        def trivial_custom_prop_handler(revision):
847
 
            return {'test_prop':'test_value'}
 
975
        wt = self.make_branch_and_tree('.')
 
976
        b = wt.branch
 
977
        self.build_tree(['a'])
 
978
        wt.add('a')
 
979
        b.nick = 'test_properties_in_log'
 
980
        wt.commit(message='add a',
 
981
                  timestamp=1132711707,
 
982
                  timezone=36000,
 
983
                  committer='Lorem Ipsum <test@example.com>',
 
984
                  authors=['John Doe <jdoe@example.com>'])
 
985
        sio = StringIO()
 
986
        formatter = log.LongLogFormatter(to_file=sio, levels=1)
 
987
        try:
 
988
            def trivial_custom_prop_handler(revision):
 
989
                return {'test_prop':'test_value'}
848
990
 
849
 
        log.properties_handler_registry.register(
850
 
            'trivial_custom_prop_handler',
851
 
            trivial_custom_prop_handler)
852
 
        self.assertFormatterResult("""\
 
991
            log.properties_handler_registry.register(
 
992
                'trivial_custom_prop_handler',
 
993
                trivial_custom_prop_handler)
 
994
            log.show_log(b, formatter)
 
995
        finally:
 
996
            log.properties_handler_registry.remove(
 
997
                'trivial_custom_prop_handler')
 
998
            self.assertEqualDiff('''\
853
999
------------------------------------------------------------
854
1000
revno: 1
855
1001
test_prop: test_value
856
1002
author: John Doe <jdoe@example.com>
857
1003
committer: Lorem Ipsum <test@example.com>
858
1004
branch nick: test_properties_in_log
859
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
1005
timestamp: Wed 2005-11-23 12:08:27 +1000
860
1006
message:
861
1007
  add a
862
 
""",
863
 
            wt.branch, log.LongLogFormatter,
864
 
            formatter_kwargs=dict(levels=1))
865
 
 
866
 
 
867
 
class TestLineLogFormatter(TestCaseForLogFormatter):
 
1008
''',
 
1009
                                 sio.getvalue())
 
1010
 
 
1011
 
 
1012
class TestLineLogFormatter(tests.TestCaseWithTransport):
868
1013
 
869
1014
    def test_line_log(self):
870
1015
        """Line log should show revno
871
1016
 
872
1017
        bug #5162
873
1018
        """
874
 
        wt = self.make_standard_commit('test-line-log',
875
 
                committer='Line-Log-Formatter Tester <test@line.log>',
876
 
                authors=[])
877
 
        self.assertFormatterResult("""\
878
 
1: Line-Log-Formatte... 2005-11-22 add a
879
 
""",
880
 
            wt.branch, log.LineLogFormatter)
 
1019
        wt = self.make_branch_and_tree('.')
 
1020
        b = wt.branch
 
1021
        self.build_tree(['a'])
 
1022
        wt.add('a')
 
1023
        b.nick = 'test-line-log'
 
1024
        wt.commit(message='add a',
 
1025
                  timestamp=1132711707,
 
1026
                  timezone=36000,
 
1027
                  committer='Line-Log-Formatter Tester <test@line.log>')
 
1028
        logfile = file('out.tmp', 'w+')
 
1029
        formatter = log.LineLogFormatter(to_file=logfile)
 
1030
        log.show_log(b, formatter)
 
1031
        logfile.flush()
 
1032
        logfile.seek(0)
 
1033
        log_contents = logfile.read()
 
1034
        self.assertEqualDiff('1: Line-Log-Formatte... 2005-11-23 add a\n',
 
1035
                             log_contents)
881
1036
 
882
1037
    def test_trailing_newlines(self):
883
1038
        wt = self.make_branch_and_tree('.')
884
 
        b = self.make_commits_with_trailing_newlines(wt)
885
 
        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
 
1039
        b = make_commits_with_trailing_newlines(wt)
 
1040
        sio = self.make_utf8_encoded_stringio()
 
1041
        lf = log.LineLogFormatter(to_file=sio)
 
1042
        log.show_log(b, lf)
 
1043
        self.assertEqualDiff("""\
 
1044
3: Joe Foo 2005-11-21 single line with trailing newline
 
1045
2: Joe Bar 2005-11-21 multiline
 
1046
1: Joe Foo 2005-11-21 simple log message
889
1047
""",
890
 
            b, log.LineLogFormatter)
 
1048
                             sio.getvalue())
 
1049
 
 
1050
    def _prepare_tree_with_merges(self, with_tags=False):
 
1051
        wt = self.make_branch_and_memory_tree('.')
 
1052
        wt.lock_write()
 
1053
        self.addCleanup(wt.unlock)
 
1054
        wt.add('')
 
1055
        wt.commit('rev-1', rev_id='rev-1',
 
1056
                  timestamp=1132586655, timezone=36000,
 
1057
                  committer='Joe Foo <joe@foo.com>')
 
1058
        wt.commit('rev-merged', rev_id='rev-2a',
 
1059
                  timestamp=1132586700, timezone=36000,
 
1060
                  committer='Joe Foo <joe@foo.com>')
 
1061
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
1062
        wt.branch.set_last_revision_info(1, 'rev-1')
 
1063
        wt.commit('rev-2', rev_id='rev-2b',
 
1064
                  timestamp=1132586800, timezone=36000,
 
1065
                  committer='Joe Foo <joe@foo.com>')
 
1066
        if with_tags:
 
1067
            branch = wt.branch
 
1068
            branch.tags.set_tag('v0.2', 'rev-2b')
 
1069
            wt.commit('rev-3', rev_id='rev-3',
 
1070
                      timestamp=1132586900, timezone=36000,
 
1071
                      committer='Jane Foo <jane@foo.com>')
 
1072
            branch.tags.set_tag('v1.0rc1', 'rev-3')
 
1073
            branch.tags.set_tag('v1.0', 'rev-3')
 
1074
        return wt
891
1075
 
892
1076
    def test_line_log_single_merge_revision(self):
893
1077
        wt = self._prepare_tree_with_merges()
 
1078
        logfile = self.make_utf8_encoded_stringio()
 
1079
        formatter = log.LineLogFormatter(to_file=logfile)
894
1080
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
895
 
        rev = revspec.in_history(wt.branch)
896
 
        self.assertFormatterResult("""\
 
1081
        wtb = wt.branch
 
1082
        rev = revspec.in_history(wtb)
 
1083
        log.show_log(wtb, formatter, start_revision=rev, end_revision=rev)
 
1084
        self.assertEqualDiff("""\
897
1085
1.1.1: Joe Foo 2005-11-22 rev-merged
898
1086
""",
899
 
            wt.branch, log.LineLogFormatter,
900
 
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
 
1087
                             logfile.getvalue())
901
1088
 
902
1089
    def test_line_log_with_tags(self):
903
1090
        wt = self._prepare_tree_with_merges(with_tags=True)
904
 
        self.assertFormatterResult("""\
905
 
3: Joe Foo 2005-11-22 {v1.0, v1.0rc1} rev-3
 
1091
        logfile = self.make_utf8_encoded_stringio()
 
1092
        formatter = log.LineLogFormatter(to_file=logfile)
 
1093
        log.show_log(wt.branch, formatter)
 
1094
        self.assertEqualDiff("""\
 
1095
3: Jane Foo 2005-11-22 {v1.0, v1.0rc1} rev-3
906
1096
2: Joe Foo 2005-11-22 [merge] {v0.2} rev-2
907
1097
1: Joe Foo 2005-11-22 rev-1
908
1098
""",
909
 
            wt.branch, log.LineLogFormatter)
910
 
 
911
 
 
912
 
class TestLineLogFormatterWithMergeRevisions(TestCaseForLogFormatter):
 
1099
                             logfile.getvalue())
 
1100
 
 
1101
class TestLineLogFormatterWithMergeRevisions(tests.TestCaseWithTransport):
913
1102
 
914
1103
    def test_line_merge_revs_log(self):
915
1104
        """Line log should show revno
916
1105
 
917
1106
        bug #5162
918
1107
        """
919
 
        wt = self.make_standard_commit('test-line-log',
920
 
                committer='Line-Log-Formatter Tester <test@line.log>',
921
 
                authors=[])
922
 
        self.assertFormatterResult("""\
923
 
1: Line-Log-Formatte... 2005-11-22 add a
924
 
""",
925
 
            wt.branch, log.LineLogFormatter)
 
1108
        wt = self.make_branch_and_tree('.')
 
1109
        b = wt.branch
 
1110
        self.build_tree(['a'])
 
1111
        wt.add('a')
 
1112
        b.nick = 'test-line-log'
 
1113
        wt.commit(message='add a',
 
1114
                  timestamp=1132711707,
 
1115
                  timezone=36000,
 
1116
                  committer='Line-Log-Formatter Tester <test@line.log>')
 
1117
        logfile = file('out.tmp', 'w+')
 
1118
        formatter = log.LineLogFormatter(to_file=logfile, levels=0)
 
1119
        log.show_log(b, formatter)
 
1120
        logfile.flush()
 
1121
        logfile.seek(0)
 
1122
        log_contents = logfile.read()
 
1123
        self.assertEqualDiff('1: Line-Log-Formatte... 2005-11-23 add a\n',
 
1124
                             log_contents)
926
1125
 
927
1126
    def test_line_merge_revs_log_single_merge_revision(self):
928
 
        wt = self._prepare_tree_with_merges()
 
1127
        wt = self.make_branch_and_memory_tree('.')
 
1128
        wt.lock_write()
 
1129
        self.addCleanup(wt.unlock)
 
1130
        wt.add('')
 
1131
        wt.commit('rev-1', rev_id='rev-1',
 
1132
                  timestamp=1132586655, timezone=36000,
 
1133
                  committer='Joe Foo <joe@foo.com>')
 
1134
        wt.commit('rev-merged', rev_id='rev-2a',
 
1135
                  timestamp=1132586700, timezone=36000,
 
1136
                  committer='Joe Foo <joe@foo.com>')
 
1137
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
1138
        wt.branch.set_last_revision_info(1, 'rev-1')
 
1139
        wt.commit('rev-2', rev_id='rev-2b',
 
1140
                  timestamp=1132586800, timezone=36000,
 
1141
                  committer='Joe Foo <joe@foo.com>')
 
1142
        logfile = self.make_utf8_encoded_stringio()
 
1143
        formatter = log.LineLogFormatter(to_file=logfile, levels=0)
929
1144
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
930
 
        rev = revspec.in_history(wt.branch)
931
 
        self.assertFormatterResult("""\
 
1145
        wtb = wt.branch
 
1146
        rev = revspec.in_history(wtb)
 
1147
        log.show_log(wtb, formatter, start_revision=rev, end_revision=rev)
 
1148
        self.assertEqualDiff("""\
932
1149
1.1.1: Joe Foo 2005-11-22 rev-merged
933
1150
""",
934
 
            wt.branch, log.LineLogFormatter,
935
 
            formatter_kwargs=dict(levels=0),
936
 
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
 
1151
                             logfile.getvalue())
937
1152
 
938
1153
    def test_line_merge_revs_log_with_merges(self):
939
 
        wt = self._prepare_tree_with_merges()
940
 
        self.assertFormatterResult("""\
 
1154
        wt = self.make_branch_and_memory_tree('.')
 
1155
        wt.lock_write()
 
1156
        self.addCleanup(wt.unlock)
 
1157
        wt.add('')
 
1158
        wt.commit('rev-1', rev_id='rev-1',
 
1159
                  timestamp=1132586655, timezone=36000,
 
1160
                  committer='Joe Foo <joe@foo.com>')
 
1161
        wt.commit('rev-merged', rev_id='rev-2a',
 
1162
                  timestamp=1132586700, timezone=36000,
 
1163
                  committer='Joe Foo <joe@foo.com>')
 
1164
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
1165
        wt.branch.set_last_revision_info(1, 'rev-1')
 
1166
        wt.commit('rev-2', rev_id='rev-2b',
 
1167
                  timestamp=1132586800, timezone=36000,
 
1168
                  committer='Joe Foo <joe@foo.com>')
 
1169
        logfile = self.make_utf8_encoded_stringio()
 
1170
        formatter = log.LineLogFormatter(to_file=logfile, levels=0)
 
1171
        log.show_log(wt.branch, formatter)
 
1172
        self.assertEqualDiff("""\
941
1173
2: Joe Foo 2005-11-22 [merge] rev-2
942
1174
  1.1.1: Joe Foo 2005-11-22 rev-merged
943
1175
1: Joe Foo 2005-11-22 rev-1
944
1176
""",
945
 
            wt.branch, log.LineLogFormatter,
946
 
            formatter_kwargs=dict(levels=0))
947
 
 
948
 
 
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))
 
1177
                             logfile.getvalue())
 
1178
 
 
1179
class TestGetViewRevisions(tests.TestCaseWithTransport):
 
1180
 
 
1181
    def make_tree_with_commits(self):
 
1182
        """Create a tree with well-known revision ids"""
 
1183
        wt = self.make_branch_and_tree('tree1')
 
1184
        wt.commit('commit one', rev_id='1')
 
1185
        wt.commit('commit two', rev_id='2')
 
1186
        wt.commit('commit three', rev_id='3')
 
1187
        mainline_revs = [None, '1', '2', '3']
 
1188
        rev_nos = {'1': 1, '2': 2, '3': 3}
 
1189
        return mainline_revs, rev_nos, wt
 
1190
 
 
1191
    def make_tree_with_merges(self):
 
1192
        """Create a tree with well-known revision ids and a merge"""
 
1193
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
 
1194
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
 
1195
        tree2.commit('four-a', rev_id='4a')
 
1196
        wt.merge_from_branch(tree2.branch)
 
1197
        wt.commit('four-b', rev_id='4b')
 
1198
        mainline_revs.append('4b')
 
1199
        rev_nos['4b'] = 4
 
1200
        # 4a: 3.1.1
 
1201
        return mainline_revs, rev_nos, wt
 
1202
 
 
1203
    def make_branch_with_many_merges(self):
 
1204
        """Create a tree with well-known revision ids"""
 
1205
        builder = self.make_branch_builder('tree1')
 
1206
        builder.start_series()
 
1207
        builder.build_snapshot('1', None, [
 
1208
            ('add', ('', 'TREE_ROOT', 'directory', '')),
 
1209
            ('add', ('f', 'f-id', 'file', '1\n'))])
 
1210
        builder.build_snapshot('2', ['1'], [])
 
1211
        builder.build_snapshot('3a', ['2'], [
 
1212
            ('modify', ('f-id', '1\n2\n3a\n'))])
 
1213
        builder.build_snapshot('3b', ['2', '3a'], [
 
1214
            ('modify', ('f-id', '1\n2\n3a\n'))])
 
1215
        builder.build_snapshot('3c', ['2', '3b'], [
 
1216
            ('modify', ('f-id', '1\n2\n3a\n'))])
 
1217
        builder.build_snapshot('4a', ['3b'], [])
 
1218
        builder.build_snapshot('4b', ['3c', '4a'], [])
 
1219
        builder.finish_series()
 
1220
 
 
1221
        # 1
 
1222
        # |
 
1223
        # 2-.
 
1224
        # |\ \
 
1225
        # | | 3a
 
1226
        # | |/
 
1227
        # | 3b
 
1228
        # |/|
 
1229
        # 3c4a
 
1230
        # |/
 
1231
        # 4b
 
1232
 
 
1233
        mainline_revs = [None, '1', '2', '3c', '4b']
 
1234
        rev_nos = {'1':1, '2':2, '3c': 3, '4b':4}
 
1235
        full_rev_nos_for_reference = {
 
1236
            '1': '1',
 
1237
            '2': '2',
 
1238
            '3a': '2.1.1', #first commit tree 3
 
1239
            '3b': '2.2.1', # first commit tree 2
 
1240
            '3c': '3', #merges 3b to main
 
1241
            '4a': '2.2.2', # second commit tree 2
 
1242
            '4b': '4', # merges 4a to main
 
1243
            }
 
1244
        return mainline_revs, rev_nos, builder.get_branch()
 
1245
 
 
1246
    def test_get_view_revisions_forward(self):
 
1247
        """Test the get_view_revisions method"""
 
1248
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
 
1249
        wt.lock_read()
 
1250
        self.addCleanup(wt.unlock)
 
1251
        revisions = list(log.get_view_revisions(
 
1252
                mainline_revs, rev_nos, wt.branch, 'forward'))
 
1253
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0)],
 
1254
                         revisions)
 
1255
        revisions2 = list(log.get_view_revisions(
 
1256
                mainline_revs, rev_nos, wt.branch, 'forward',
 
1257
                include_merges=False))
 
1258
        self.assertEqual(revisions, revisions2)
 
1259
 
 
1260
    def test_get_view_revisions_reverse(self):
 
1261
        """Test the get_view_revisions with reverse"""
 
1262
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
 
1263
        wt.lock_read()
 
1264
        self.addCleanup(wt.unlock)
 
1265
        revisions = list(log.get_view_revisions(
 
1266
                mainline_revs, rev_nos, wt.branch, 'reverse'))
 
1267
        self.assertEqual([('3', '3', 0), ('2', '2', 0), ('1', '1', 0), ],
 
1268
                         revisions)
 
1269
        revisions2 = list(log.get_view_revisions(
 
1270
                mainline_revs, rev_nos, wt.branch, 'reverse',
 
1271
                include_merges=False))
 
1272
        self.assertEqual(revisions, revisions2)
 
1273
 
 
1274
    def test_get_view_revisions_merge(self):
 
1275
        """Test get_view_revisions when there are merges"""
 
1276
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
 
1277
        wt.lock_read()
 
1278
        self.addCleanup(wt.unlock)
 
1279
        revisions = list(log.get_view_revisions(
 
1280
                mainline_revs, rev_nos, wt.branch, 'forward'))
 
1281
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0),
 
1282
                          ('4b', '4', 0), ('4a', '3.1.1', 1)],
 
1283
                         revisions)
 
1284
        revisions = list(log.get_view_revisions(
 
1285
                mainline_revs, rev_nos, wt.branch, 'forward',
 
1286
                include_merges=False))
 
1287
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0),
 
1288
                          ('4b', '4', 0)],
 
1289
                         revisions)
 
1290
 
 
1291
    def test_get_view_revisions_merge_reverse(self):
 
1292
        """Test get_view_revisions in reverse when there are merges"""
 
1293
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
 
1294
        wt.lock_read()
 
1295
        self.addCleanup(wt.unlock)
 
1296
        revisions = list(log.get_view_revisions(
 
1297
                mainline_revs, rev_nos, wt.branch, 'reverse'))
 
1298
        self.assertEqual([('4b', '4', 0), ('4a', '3.1.1', 1),
 
1299
                          ('3', '3', 0), ('2', '2', 0), ('1', '1', 0)],
 
1300
                         revisions)
 
1301
        revisions = list(log.get_view_revisions(
 
1302
                mainline_revs, rev_nos, wt.branch, 'reverse',
 
1303
                include_merges=False))
 
1304
        self.assertEqual([('4b', '4', 0), ('3', '3', 0), ('2', '2', 0),
 
1305
                          ('1', '1', 0)],
 
1306
                         revisions)
 
1307
 
 
1308
    def test_get_view_revisions_merge2(self):
 
1309
        """Test get_view_revisions when there are merges"""
 
1310
        mainline_revs, rev_nos, b = self.make_branch_with_many_merges()
 
1311
        b.lock_read()
 
1312
        self.addCleanup(b.unlock)
 
1313
        revisions = list(log.get_view_revisions(
 
1314
                mainline_revs, rev_nos, b, 'forward'))
 
1315
        expected = [('1', '1', 0), ('2', '2', 0), ('3c', '3', 0),
 
1316
                    ('3b', '2.2.1', 1), ('3a', '2.1.1', 2), ('4b', '4', 0),
 
1317
                    ('4a', '2.2.2', 1)]
 
1318
        self.assertEqual(expected, revisions)
 
1319
        revisions = list(log.get_view_revisions(
 
1320
                mainline_revs, rev_nos, b, 'forward',
 
1321
                include_merges=False))
 
1322
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3c', '3', 0),
 
1323
                          ('4b', '4', 0)],
 
1324
                         revisions)
 
1325
 
 
1326
 
 
1327
    def test_file_id_for_range(self):
 
1328
        mainline_revs, rev_nos, b = self.make_branch_with_many_merges()
 
1329
        b.lock_read()
 
1330
        self.addCleanup(b.unlock)
 
1331
 
 
1332
        def rev_from_rev_id(revid, branch):
 
1333
            revspec = revisionspec.RevisionSpec.from_string('revid:%s' % revid)
 
1334
            return revspec.in_history(branch)
 
1335
 
 
1336
        def view_revs(start_rev, end_rev, file_id, direction):
 
1337
            revs = log.calculate_view_revisions(
 
1338
                b,
 
1339
                start_rev, # start_revision
 
1340
                end_rev, # end_revision
 
1341
                direction, # direction
 
1342
                file_id, # specific_fileid
 
1343
                True, # generate_merge_revisions
 
1344
                )
 
1345
            return revs
 
1346
 
 
1347
        rev_3a = rev_from_rev_id('3a', b)
 
1348
        rev_4b = rev_from_rev_id('4b', b)
 
1349
        self.assertEqual([('3c', '3', 0), ('3b', '2.2.1', 1), ('3a', '2.1.1', 2)],
 
1350
                          view_revs(rev_3a, rev_4b, 'f-id', 'reverse'))
 
1351
        # Note: 3c still appears before 3a here because of depth-based sorting
 
1352
        self.assertEqual([('3c', '3', 0), ('3b', '2.2.1', 1), ('3a', '2.1.1', 2)],
 
1353
                          view_revs(rev_3a, rev_4b, 'f-id', 'forward'))
 
1354
 
 
1355
 
 
1356
class TestGetRevisionsTouchingFileID(tests.TestCaseWithTransport):
 
1357
 
 
1358
    def create_tree_with_single_merge(self):
 
1359
        """Create a branch with a moderate layout.
 
1360
 
 
1361
        The revision graph looks like:
 
1362
 
 
1363
           A
 
1364
           |\
 
1365
           B C
 
1366
           |/
 
1367
           D
 
1368
 
 
1369
        In this graph, A introduced files f1 and f2 and f3.
 
1370
        B modifies f1 and f3, and C modifies f2 and f3.
 
1371
        D merges the changes from B and C and resolves the conflict for f3.
 
1372
        """
 
1373
        # TODO: jam 20070218 This seems like it could really be done
 
1374
        #       with make_branch_and_memory_tree() if we could just
 
1375
        #       create the content of those files.
 
1376
        # TODO: jam 20070218 Another alternative is that we would really
 
1377
        #       like to only create this tree 1 time for all tests that
 
1378
        #       use it. Since 'log' only uses the tree in a readonly
 
1379
        #       fashion, it seems a shame to regenerate an identical
 
1380
        #       tree for each test.
 
1381
        tree = self.make_branch_and_tree('tree')
 
1382
        tree.lock_write()
 
1383
        self.addCleanup(tree.unlock)
 
1384
 
 
1385
        self.build_tree_contents([('tree/f1', 'A\n'),
 
1386
                                  ('tree/f2', 'A\n'),
 
1387
                                  ('tree/f3', 'A\n'),
 
1388
                                 ])
 
1389
        tree.add(['f1', 'f2', 'f3'], ['f1-id', 'f2-id', 'f3-id'])
 
1390
        tree.commit('A', rev_id='A')
 
1391
 
 
1392
        self.build_tree_contents([('tree/f2', 'A\nC\n'),
 
1393
                                  ('tree/f3', 'A\nC\n'),
 
1394
                                 ])
 
1395
        tree.commit('C', rev_id='C')
 
1396
        # Revert back to A to build the other history.
 
1397
        tree.set_last_revision('A')
 
1398
        tree.branch.set_last_revision_info(1, 'A')
 
1399
        self.build_tree_contents([('tree/f1', 'A\nB\n'),
 
1400
                                  ('tree/f2', 'A\n'),
 
1401
                                  ('tree/f3', 'A\nB\n'),
 
1402
                                 ])
 
1403
        tree.commit('B', rev_id='B')
 
1404
        tree.set_parent_ids(['B', 'C'])
 
1405
        self.build_tree_contents([('tree/f1', 'A\nB\n'),
 
1406
                                  ('tree/f2', 'A\nC\n'),
 
1407
                                  ('tree/f3', 'A\nB\nC\n'),
 
1408
                                 ])
 
1409
        tree.commit('D', rev_id='D')
 
1410
 
 
1411
        # Switch to a read lock for this tree.
 
1412
        # We still have an addCleanup(tree.unlock) pending
 
1413
        tree.unlock()
 
1414
        tree.lock_read()
 
1415
        return tree
 
1416
 
 
1417
    def check_delta(self, delta, **kw):
 
1418
        """Check the filenames touched by a delta are as expected.
 
1419
 
 
1420
        Caller only have to pass in the list of files for each part, all
 
1421
        unspecified parts are considered empty (and checked as such).
 
1422
        """
 
1423
        for n in 'added', 'removed', 'renamed', 'modified', 'unchanged':
 
1424
            # By default we expect an empty list
 
1425
            expected = kw.get(n, [])
 
1426
            # strip out only the path components
 
1427
            got = [x[0] for x in getattr(delta, n)]
 
1428
            self.assertEqual(expected, got)
 
1429
 
 
1430
    def test_tree_with_single_merge(self):
 
1431
        """Make sure the tree layout is correct."""
 
1432
        tree = self.create_tree_with_single_merge()
 
1433
        rev_A_tree = tree.branch.repository.revision_tree('A')
 
1434
        rev_B_tree = tree.branch.repository.revision_tree('B')
 
1435
        rev_C_tree = tree.branch.repository.revision_tree('C')
 
1436
        rev_D_tree = tree.branch.repository.revision_tree('D')
 
1437
 
 
1438
        self.check_delta(rev_B_tree.changes_from(rev_A_tree),
 
1439
                         modified=['f1', 'f3'])
 
1440
 
 
1441
        self.check_delta(rev_C_tree.changes_from(rev_A_tree),
 
1442
                         modified=['f2', 'f3'])
 
1443
 
 
1444
        self.check_delta(rev_D_tree.changes_from(rev_B_tree),
 
1445
                         modified=['f2', 'f3'])
 
1446
 
 
1447
        self.check_delta(rev_D_tree.changes_from(rev_C_tree),
 
1448
                         modified=['f1', 'f3'])
 
1449
 
 
1450
    def assertAllRevisionsForFileID(self, tree, file_id, revisions):
 
1451
        """Ensure _filter_revisions_touching_file_id returns the right values.
 
1452
 
 
1453
        Get the return value from _filter_revisions_touching_file_id and make
 
1454
        sure they are correct.
 
1455
        """
 
1456
        # The api for _filter_revisions_touching_file_id is a little crazy.
 
1457
        # So we do the setup here.
 
1458
        mainline = tree.branch.revision_history()
 
1459
        mainline.insert(0, None)
 
1460
        revnos = dict((rev, idx+1) for idx, rev in enumerate(mainline))
 
1461
        view_revs_iter = log.get_view_revisions(mainline, revnos, tree.branch,
 
1462
                                                'reverse', True)
 
1463
        actual_revs = log._filter_revisions_touching_file_id(
 
1464
                            tree.branch,
 
1465
                            file_id,
 
1466
                            list(view_revs_iter))
 
1467
        self.assertEqual(revisions, [r for r, revno, depth in actual_revs])
 
1468
 
 
1469
    def test_file_id_f1(self):
 
1470
        tree = self.create_tree_with_single_merge()
 
1471
        # f1 should be marked as modified by revisions A and B
 
1472
        self.assertAllRevisionsForFileID(tree, 'f1-id', ['B', 'A'])
 
1473
 
 
1474
    def test_file_id_f2(self):
 
1475
        tree = self.create_tree_with_single_merge()
 
1476
        # f2 should be marked as modified by revisions A, C, and D
 
1477
        # because D merged the changes from C.
 
1478
        self.assertAllRevisionsForFileID(tree, 'f2-id', ['D', 'C', 'A'])
 
1479
 
 
1480
    def test_file_id_f3(self):
 
1481
        tree = self.create_tree_with_single_merge()
 
1482
        # f3 should be marked as modified by revisions A, B, C, and D
 
1483
        self.assertAllRevisionsForFileID(tree, 'f3-id', ['D', 'C', 'B', 'A'])
 
1484
 
 
1485
    def test_file_id_with_ghosts(self):
 
1486
        # This is testing bug #209948, where having a ghost would cause
 
1487
        # _filter_revisions_touching_file_id() to fail.
 
1488
        tree = self.create_tree_with_single_merge()
 
1489
        # We need to add a revision, so switch back to a write-locked tree
 
1490
        # (still a single addCleanup(tree.unlock) pending).
 
1491
        tree.unlock()
 
1492
        tree.lock_write()
 
1493
        first_parent = tree.last_revision()
 
1494
        tree.set_parent_ids([first_parent, 'ghost-revision-id'])
 
1495
        self.build_tree_contents([('tree/f1', 'A\nB\nXX\n')])
 
1496
        tree.commit('commit with a ghost', rev_id='XX')
 
1497
        self.assertAllRevisionsForFileID(tree, 'f1-id', ['XX', 'B', 'A'])
 
1498
        self.assertAllRevisionsForFileID(tree, 'f2-id', ['D', 'C', 'A'])
 
1499
 
 
1500
    def test_unknown_file_id(self):
 
1501
        tree = self.create_tree_with_single_merge()
 
1502
        self.assertAllRevisionsForFileID(tree, 'unknown', [])
 
1503
 
 
1504
    def test_empty_branch_unknown_file_id(self):
 
1505
        tree = self.make_branch_and_tree('tree')
 
1506
        self.assertAllRevisionsForFileID(tree, 'unknown', [])
985
1507
 
986
1508
 
987
1509
class TestShowChangedRevisions(tests.TestCaseWithTransport):
999
1521
 
1000
1522
class TestLogFormatter(tests.TestCase):
1001
1523
 
1002
 
    def setUp(self):
1003
 
        super(TestLogFormatter, self).setUp()
1004
 
        self.rev = revision.Revision('a-id')
1005
 
        self.lf = log.LogFormatter(None)
1006
 
 
1007
1524
    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')
 
1525
        rev = revision.Revision('a-id')
 
1526
        rev.committer = 'John Doe <jdoe@example.com>'
 
1527
        lf = log.LogFormatter(None)
 
1528
        self.assertEqual('John Doe', lf.short_committer(rev))
 
1529
        rev.committer = 'John Smith <jsmith@example.com>'
 
1530
        self.assertEqual('John Smith', lf.short_committer(rev))
 
1531
        rev.committer = 'John Smith'
 
1532
        self.assertEqual('John Smith', lf.short_committer(rev))
 
1533
        rev.committer = 'jsmith@example.com'
 
1534
        self.assertEqual('jsmith@example.com', lf.short_committer(rev))
 
1535
        rev.committer = '<jsmith@example.com>'
 
1536
        self.assertEqual('jsmith@example.com', lf.short_committer(rev))
 
1537
        rev.committer = 'John Smith jsmith@example.com'
 
1538
        self.assertEqual('John Smith', lf.short_committer(rev))
1018
1539
 
1019
1540
    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))
 
1541
        rev = revision.Revision('a-id')
 
1542
        rev.committer = 'John Doe <jdoe@example.com>'
 
1543
        lf = log.LogFormatter(None)
 
1544
        self.assertEqual('John Doe', lf.short_author(rev))
 
1545
        rev.properties['author'] = 'John Smith <jsmith@example.com>'
 
1546
        self.assertEqual('John Smith', lf.short_author(rev))
 
1547
        rev.properties['author'] = 'John Smith'
 
1548
        self.assertEqual('John Smith', lf.short_author(rev))
 
1549
        rev.properties['author'] = 'jsmith@example.com'
 
1550
        self.assertEqual('jsmith@example.com', lf.short_author(rev))
 
1551
        rev.properties['author'] = '<jsmith@example.com>'
 
1552
        self.assertEqual('jsmith@example.com', lf.short_author(rev))
 
1553
        rev.properties['author'] = 'John Smith jsmith@example.com'
 
1554
        self.assertEqual('John Smith', lf.short_author(rev))
 
1555
        del rev.properties['author']
 
1556
        rev.properties['authors'] = ('John Smith <jsmith@example.com>\n'
 
1557
                'Jane Rey <jrey@example.com>')
 
1558
        self.assertEqual('John Smith', lf.short_author(rev))
1038
1559
 
1039
1560
 
1040
1561
class TestReverseByDepth(tests.TestCase):
1186
1707
        log.show_branch_change(tree.branch, s, 3, '3b')
1187
1708
        self.assertContainsRe(s.getvalue(), 'Removed Revisions:')
1188
1709
        self.assertNotContainsRe(s.getvalue(), 'Added Revisions:')
1189
 
 
1190
 
 
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):
1311
 
 
1312
 
    def setUp(self):
1313
 
        TestCaseForLogFormatter.setUp(self)
1314
 
        log.properties_handler_registry.register(
1315
 
            'bugs_properties_handler',
1316
 
            log._bugs_properties_handler)
1317
 
 
1318
 
    def make_commits_with_bugs(self):
1319
 
        """Helper method for LogFormatter tests"""
1320
 
        tree = self.make_branch_and_tree(u'.')
1321
 
        self.build_tree(['a', 'b'])
1322
 
        tree.add('a')
1323
 
        self.wt_commit(tree, 'simple log message', rev_id='a1',
1324
 
                       revprops={'bugs': 'test://bug/id fixed'})
1325
 
        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'})
1330
 
        return tree
1331
 
 
1332
 
 
1333
 
    def test_long_bugs(self):
1334
 
        tree = self.make_commits_with_bugs()
1335
 
        self.assertFormatterResult("""\
1336
 
------------------------------------------------------------
1337
 
revno: 2
1338
 
fixes bug(s): test://bug/id test://bug/2
1339
 
author: Joe Bar <joe@bar.com>
1340
 
committer: Joe Foo <joe@foo.com>
1341
 
branch nick: work
1342
 
timestamp: Tue 2005-11-22 00:00:01 +0000
1343
 
message:
1344
 
  multiline
1345
 
  log
1346
 
  message
1347
 
------------------------------------------------------------
1348
 
revno: 1
1349
 
fixes bug(s): test://bug/id
1350
 
committer: Joe Foo <joe@foo.com>
1351
 
branch nick: work
1352
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1353
 
message:
1354
 
  simple log message
1355
 
""",
1356
 
            tree.branch, log.LongLogFormatter)
1357
 
 
1358
 
    def test_short_bugs(self):
1359
 
        tree = self.make_commits_with_bugs()
1360
 
        self.assertFormatterResult("""\
1361
 
    2 Joe Bar\t2005-11-22
1362
 
      fixes bug(s): test://bug/id test://bug/2
1363
 
      multiline
1364
 
      log
1365
 
      message
1366
 
 
1367
 
    1 Joe Foo\t2005-11-22
1368
 
      fixes bug(s): test://bug/id
1369
 
      simple log message
1370
 
 
1371
 
""",
1372
 
            tree.branch, log.ShortLogFormatter)
1373
 
 
1374
 
    def test_wrong_bugs_property(self):
1375
 
        tree = self.make_branch_and_tree(u'.')
1376
 
        self.build_tree(['foo'])
1377
 
        self.wt_commit(tree, 'simple log message', rev_id='a1',
1378
 
                       revprops={'bugs': 'test://bug/id invalid_value'})
1379
 
        self.assertFormatterResult("""\
1380
 
    1 Joe Foo\t2005-11-22
1381
 
      simple log message
1382
 
 
1383
 
""",
1384
 
            tree.branch, log.ShortLogFormatter)
1385
 
 
1386
 
    def test_bugs_handler_present(self):
1387
 
        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)