← 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: Canonical.com Patch Queue Manager
  • Date: 2009-06-22 17:11:20 UTC
  • mfrom: (4398.8.10 1.16-commit-fulltext)
  • Revision ID: pqm@pqm.ubuntu.com-20090622171120-fuxez9ylfqpxynqn
(jam) Add VF._add_text and reduce memory overhead during commit (see
        bug #109114)

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