← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_log.py

Merge bzr.dev.

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))
985
 
 
986
 
class TestGetViewRevisions(tests.TestCaseWithTransport, TestLogMixin):
987
 
 
988
 
    def _get_view_revisions(self, *args, **kwargs):
989
 
        return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
990
 
                                    log.get_view_revisions, *args, **kwargs)
 
1174
                             logfile.getvalue())
 
1175
 
 
1176
class TestGetViewRevisions(tests.TestCaseWithTransport):
991
1177
 
992
1178
    def make_tree_with_commits(self):
993
1179
        """Create a tree with well-known revision ids"""
994
1180
        wt = self.make_branch_and_tree('tree1')
995
 
        self.wt_commit(wt, 'commit one', rev_id='1')
996
 
        self.wt_commit(wt, 'commit two', rev_id='2')
997
 
        self.wt_commit(wt, 'commit three', rev_id='3')
 
1181
        wt.commit('commit one', rev_id='1')
 
1182
        wt.commit('commit two', rev_id='2')
 
1183
        wt.commit('commit three', rev_id='3')
998
1184
        mainline_revs = [None, '1', '2', '3']
999
1185
        rev_nos = {'1': 1, '2': 2, '3': 3}
1000
1186
        return mainline_revs, rev_nos, wt
1003
1189
        """Create a tree with well-known revision ids and a merge"""
1004
1190
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
1005
1191
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
1006
 
        self.wt_commit(tree2, 'four-a', rev_id='4a')
 
1192
        tree2.commit('four-a', rev_id='4a')
1007
1193
        wt.merge_from_branch(tree2.branch)
1008
 
        self.wt_commit(wt, 'four-b', rev_id='4b')
 
1194
        wt.commit('four-b', rev_id='4b')
1009
1195
        mainline_revs.append('4b')
1010
1196
        rev_nos['4b'] = 4
1011
1197
        # 4a: 3.1.1
1012
1198
        return mainline_revs, rev_nos, wt
1013
1199
 
1014
 
    def make_branch_with_many_merges(self):
 
1200
    def make_tree_with_many_merges(self):
1015
1201
        """Create a tree with well-known revision ids"""
1016
 
        builder = self.make_branch_builder('tree1')
1017
 
        builder.start_series()
1018
 
        builder.build_snapshot('1', None, [
1019
 
            ('add', ('', 'TREE_ROOT', 'directory', '')),
1020
 
            ('add', ('f', 'f-id', 'file', '1\n'))])
1021
 
        builder.build_snapshot('2', ['1'], [])
1022
 
        builder.build_snapshot('3a', ['2'], [
1023
 
            ('modify', ('f-id', '1\n2\n3a\n'))])
1024
 
        builder.build_snapshot('3b', ['2', '3a'], [
1025
 
            ('modify', ('f-id', '1\n2\n3a\n'))])
1026
 
        builder.build_snapshot('3c', ['2', '3b'], [
1027
 
            ('modify', ('f-id', '1\n2\n3a\n'))])
1028
 
        builder.build_snapshot('4a', ['3b'], [])
1029
 
        builder.build_snapshot('4b', ['3c', '4a'], [])
1030
 
        builder.finish_series()
1031
 
 
1032
 
        # 1
1033
 
        # |
1034
 
        # 2-.
1035
 
        # |\ \
1036
 
        # | | 3a
1037
 
        # | |/
1038
 
        # | 3b
1039
 
        # |/|
1040
 
        # 3c4a
1041
 
        # |/
1042
 
        # 4b
 
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')
1043
1222
 
1044
1223
        mainline_revs = [None, '1', '2', '3c', '4b']
1045
1224
        rev_nos = {'1':1, '2':2, '3c': 3, '4b':4}
1052
1231
            '4a': '2.2.2', # second commit tree 2
1053
1232
            '4b': '4', # merges 4a to main
1054
1233
            }
1055
 
        return mainline_revs, rev_nos, builder.get_branch()
 
1234
        return mainline_revs, rev_nos, wt
1056
1235
 
1057
1236
    def test_get_view_revisions_forward(self):
1058
1237
        """Test the get_view_revisions method"""
1059
1238
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
1060
1239
        wt.lock_read()
1061
1240
        self.addCleanup(wt.unlock)
1062
 
        revisions = list(self._get_view_revisions(
 
1241
        revisions = list(log.get_view_revisions(
1063
1242
                mainline_revs, rev_nos, wt.branch, 'forward'))
1064
1243
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0)],
1065
1244
                         revisions)
1066
 
        revisions2 = list(self._get_view_revisions(
 
1245
        revisions2 = list(log.get_view_revisions(
1067
1246
                mainline_revs, rev_nos, wt.branch, 'forward',
1068
1247
                include_merges=False))
1069
1248
        self.assertEqual(revisions, revisions2)
1073
1252
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
1074
1253
        wt.lock_read()
1075
1254
        self.addCleanup(wt.unlock)
1076
 
        revisions = list(self._get_view_revisions(
 
1255
        revisions = list(log.get_view_revisions(
1077
1256
                mainline_revs, rev_nos, wt.branch, 'reverse'))
1078
1257
        self.assertEqual([('3', '3', 0), ('2', '2', 0), ('1', '1', 0), ],
1079
1258
                         revisions)
1080
 
        revisions2 = list(self._get_view_revisions(
 
1259
        revisions2 = list(log.get_view_revisions(
1081
1260
                mainline_revs, rev_nos, wt.branch, 'reverse',
1082
1261
                include_merges=False))
1083
1262
        self.assertEqual(revisions, revisions2)
1087
1266
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
1088
1267
        wt.lock_read()
1089
1268
        self.addCleanup(wt.unlock)
1090
 
        revisions = list(self._get_view_revisions(
 
1269
        revisions = list(log.get_view_revisions(
1091
1270
                mainline_revs, rev_nos, wt.branch, 'forward'))
1092
1271
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0),
1093
1272
                          ('4b', '4', 0), ('4a', '3.1.1', 1)],
1094
1273
                         revisions)
1095
 
        revisions = list(self._get_view_revisions(
 
1274
        revisions = list(log.get_view_revisions(
1096
1275
                mainline_revs, rev_nos, wt.branch, 'forward',
1097
1276
                include_merges=False))
1098
1277
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0),
1104
1283
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
1105
1284
        wt.lock_read()
1106
1285
        self.addCleanup(wt.unlock)
1107
 
        revisions = list(self._get_view_revisions(
 
1286
        revisions = list(log.get_view_revisions(
1108
1287
                mainline_revs, rev_nos, wt.branch, 'reverse'))
1109
1288
        self.assertEqual([('4b', '4', 0), ('4a', '3.1.1', 1),
1110
1289
                          ('3', '3', 0), ('2', '2', 0), ('1', '1', 0)],
1111
1290
                         revisions)
1112
 
        revisions = list(self._get_view_revisions(
 
1291
        revisions = list(log.get_view_revisions(
1113
1292
                mainline_revs, rev_nos, wt.branch, 'reverse',
1114
1293
                include_merges=False))
1115
1294
        self.assertEqual([('4b', '4', 0), ('3', '3', 0), ('2', '2', 0),
1118
1297
 
1119
1298
    def test_get_view_revisions_merge2(self):
1120
1299
        """Test get_view_revisions when there are merges"""
1121
 
        mainline_revs, rev_nos, b = self.make_branch_with_many_merges()
1122
 
        b.lock_read()
1123
 
        self.addCleanup(b.unlock)
1124
 
        revisions = list(self._get_view_revisions(
1125
 
                mainline_revs, rev_nos, b, 'forward'))
 
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'))
1126
1305
        expected = [('1', '1', 0), ('2', '2', 0), ('3c', '3', 0),
1127
 
                    ('3b', '2.2.1', 1), ('3a', '2.1.1', 2), ('4b', '4', 0),
 
1306
                    ('3a', '2.1.1', 1), ('3b', '2.2.1', 1), ('4b', '4', 0),
1128
1307
                    ('4a', '2.2.2', 1)]
1129
1308
        self.assertEqual(expected, revisions)
1130
 
        revisions = list(self._get_view_revisions(
1131
 
                mainline_revs, rev_nos, b, 'forward',
 
1309
        revisions = list(log.get_view_revisions(
 
1310
                mainline_revs, rev_nos, wt.branch, 'forward',
1132
1311
                include_merges=False))
1133
1312
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3c', '3', 0),
1134
1313
                          ('4b', '4', 0)],
1135
1314
                         revisions)
1136
1315
 
 
1316
 
1137
1317
    def test_file_id_for_range(self):
1138
 
        mainline_revs, rev_nos, b = self.make_branch_with_many_merges()
1139
 
        b.lock_read()
1140
 
        self.addCleanup(b.unlock)
 
1318
        mainline_revs, rev_nos, wt = self.make_tree_with_many_merges()
 
1319
        wt.lock_read()
 
1320
        self.addCleanup(wt.unlock)
1141
1321
 
1142
1322
        def rev_from_rev_id(revid, branch):
1143
1323
            revspec = revisionspec.RevisionSpec.from_string('revid:%s' % revid)
1144
1324
            return revspec.in_history(branch)
1145
1325
 
1146
1326
        def view_revs(start_rev, end_rev, file_id, direction):
1147
 
            revs = self.applyDeprecated(
1148
 
                symbol_versioning.deprecated_in((2, 2, 0)),
1149
 
                log.calculate_view_revisions,
1150
 
                b,
 
1327
            revs = log.calculate_view_revisions(
 
1328
                wt.branch,
1151
1329
                start_rev, # start_revision
1152
1330
                end_rev, # end_revision
1153
1331
                direction, # direction
1156
1334
                )
1157
1335
            return revs
1158
1336
 
1159
 
        rev_3a = rev_from_rev_id('3a', b)
1160
 
        rev_4b = rev_from_rev_id('4b', b)
1161
 
        self.assertEqual([('3c', '3', 0), ('3b', '2.2.1', 1),
1162
 
                          ('3a', '2.1.1', 2)],
 
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)],
1163
1340
                          view_revs(rev_3a, rev_4b, 'f-id', 'reverse'))
1164
1341
        # Note: 3c still appears before 3a here because of depth-based sorting
1165
 
        self.assertEqual([('3c', '3', 0), ('3b', '2.2.1', 1),
1166
 
                          ('3a', '2.1.1', 2)],
 
1342
        self.assertEqual([('3c', '3', 0), ('3a', '2.1.1', 1)],
1167
1343
                          view_revs(rev_3a, rev_4b, 'f-id', 'forward'))
1168
1344
 
1169
1345
 
1170
1346
class TestGetRevisionsTouchingFileID(tests.TestCaseWithTransport):
1171
1347
 
1172
 
    def get_view_revisions(self, *args):
1173
 
        return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
1174
 
                                    log.get_view_revisions, *args)
1175
 
 
1176
1348
    def create_tree_with_single_merge(self):
1177
1349
        """Create a branch with a moderate layout.
1178
1350
 
1196
1368
        #       use it. Since 'log' only uses the tree in a readonly
1197
1369
        #       fashion, it seems a shame to regenerate an identical
1198
1370
        #       tree for each test.
1199
 
        # TODO: vila 20100122 One way to address the shame above will be to
1200
 
        #       create a memory tree during test parametrization and give a
1201
 
        #       *copy* of this tree to each test. Copying a memory tree ought
1202
 
        #       to be cheap, at least cheaper than creating them with such
1203
 
        #       complex setups.
1204
1371
        tree = self.make_branch_and_tree('tree')
1205
1372
        tree.lock_write()
1206
1373
        self.addCleanup(tree.unlock)
1281
1448
        mainline = tree.branch.revision_history()
1282
1449
        mainline.insert(0, None)
1283
1450
        revnos = dict((rev, idx+1) for idx, rev in enumerate(mainline))
1284
 
        view_revs_iter = self.get_view_revisions(
1285
 
            mainline, revnos, tree.branch, 'reverse', True)
 
1451
        view_revs_iter = log.get_view_revisions(mainline, revnos, tree.branch,
 
1452
                                                'reverse', True)
1286
1453
        actual_revs = log._filter_revisions_touching_file_id(
1287
 
            tree.branch, file_id, list(view_revs_iter))
 
1454
                            tree.branch,
 
1455
                            file_id,
 
1456
                            list(view_revs_iter))
1288
1457
        self.assertEqual(revisions, [r for r, revno, depth in actual_revs])
1289
1458
 
1290
1459
    def test_file_id_f1(self):
1342
1511
 
1343
1512
class TestLogFormatter(tests.TestCase):
1344
1513
 
1345
 
    def setUp(self):
1346
 
        super(TestLogFormatter, self).setUp()
1347
 
        self.rev = revision.Revision('a-id')
1348
 
        self.lf = log.LogFormatter(None)
1349
 
 
1350
1514
    def test_short_committer(self):
1351
 
        def assertCommitter(expected, committer):
1352
 
            self.rev.committer = committer
1353
 
            self.assertEqual(expected, self.lf.short_committer(self.rev))
1354
 
 
1355
 
        assertCommitter('John Doe', 'John Doe <jdoe@example.com>')
1356
 
        assertCommitter('John Smith', 'John Smith <jsmith@example.com>')
1357
 
        assertCommitter('John Smith', 'John Smith')
1358
 
        assertCommitter('jsmith@example.com', 'jsmith@example.com')
1359
 
        assertCommitter('jsmith@example.com', '<jsmith@example.com>')
1360
 
        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))
1361
1529
 
1362
1530
    def test_short_author(self):
1363
 
        def assertAuthor(expected, author):
1364
 
            self.rev.properties['author'] = author
1365
 
            self.assertEqual(expected, self.lf.short_author(self.rev))
1366
 
 
1367
 
        assertAuthor('John Smith', 'John Smith <jsmith@example.com>')
1368
 
        assertAuthor('John Smith', 'John Smith')
1369
 
        assertAuthor('jsmith@example.com', 'jsmith@example.com')
1370
 
        assertAuthor('jsmith@example.com', '<jsmith@example.com>')
1371
 
        assertAuthor('John Smith', 'John Smith jsmith@example.com')
1372
 
 
1373
 
    def test_short_author_from_committer(self):
1374
 
        self.rev.committer = 'John Doe <jdoe@example.com>'
1375
 
        self.assertEqual('John Doe', self.lf.short_author(self.rev))
1376
 
 
1377
 
    def test_short_author_from_authors(self):
1378
 
        self.rev.properties['authors'] = ('John Smith <jsmith@example.com>\n'
1379
 
                                          'Jane Rey <jrey@example.com>')
1380
 
        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))
1381
1549
 
1382
1550
 
1383
1551
class TestReverseByDepth(tests.TestCase):
1529
1697
        log.show_branch_change(tree.branch, s, 3, '3b')
1530
1698
        self.assertContainsRe(s.getvalue(), 'Removed Revisions:')
1531
1699
        self.assertNotContainsRe(s.getvalue(), 'Added Revisions:')
1532
 
 
1533
 
 
1534
 
class TestRevisionNotInBranch(TestCaseForLogFormatter):
1535
 
 
1536
 
    def setup_a_tree(self):
1537
 
        tree = self.make_branch_and_tree('tree')
1538
 
        tree.lock_write()
1539
 
        self.addCleanup(tree.unlock)
1540
 
        kwargs = {
1541
 
            'committer': 'Joe Foo <joe@foo.com>',
1542
 
            'timestamp': 1132617600, # Mon 2005-11-22 00:00:00 +0000
1543
 
            'timezone': 0, # UTC
1544
 
        }
1545
 
        tree.commit('commit 1a', rev_id='1a', **kwargs)
1546
 
        tree.commit('commit 2a', rev_id='2a', **kwargs)
1547
 
        tree.commit('commit 3a', rev_id='3a', **kwargs)
1548
 
        return tree
1549
 
 
1550
 
    def setup_ab_tree(self):
1551
 
        tree = self.setup_a_tree()
1552
 
        tree.set_last_revision('1a')
1553
 
        tree.branch.set_last_revision_info(1, '1a')
1554
 
        kwargs = {
1555
 
            'committer': 'Joe Foo <joe@foo.com>',
1556
 
            'timestamp': 1132617600, # Mon 2005-11-22 00:00:00 +0000
1557
 
            'timezone': 0, # UTC
1558
 
        }
1559
 
        tree.commit('commit 2b', rev_id='2b', **kwargs)
1560
 
        tree.commit('commit 3b', rev_id='3b', **kwargs)
1561
 
        return tree
1562
 
 
1563
 
    def test_one_revision(self):
1564
 
        tree = self.setup_ab_tree()
1565
 
        lf = LogCatcher()
1566
 
        rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1567
 
        log.show_log(tree.branch, lf, verbose=True, start_revision=rev,
1568
 
                     end_revision=rev)
1569
 
        self.assertEqual(1, len(lf.revisions))
1570
 
        self.assertEqual(None, lf.revisions[0].revno)   # Out-of-branch
1571
 
        self.assertEqual('3a', lf.revisions[0].rev.revision_id)
1572
 
 
1573
 
    def test_many_revisions(self):
1574
 
        tree = self.setup_ab_tree()
1575
 
        lf = LogCatcher()
1576
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
1577
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1578
 
        log.show_log(tree.branch, lf, verbose=True, start_revision=start_rev,
1579
 
                     end_revision=end_rev)
1580
 
        self.assertEqual(3, len(lf.revisions))
1581
 
        self.assertEqual(None, lf.revisions[0].revno)   # Out-of-branch
1582
 
        self.assertEqual('3a', lf.revisions[0].rev.revision_id)
1583
 
        self.assertEqual(None, lf.revisions[1].revno)   # Out-of-branch
1584
 
        self.assertEqual('2a', lf.revisions[1].rev.revision_id)
1585
 
        self.assertEqual('1', lf.revisions[2].revno)    # In-branch
1586
 
 
1587
 
    def test_long_format(self):
1588
 
        tree = self.setup_ab_tree()
1589
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
1590
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1591
 
        self.assertFormatterResult("""\
1592
 
------------------------------------------------------------
1593
 
revision-id: 3a
1594
 
committer: Joe Foo <joe@foo.com>
1595
 
branch nick: tree
1596
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1597
 
message:
1598
 
  commit 3a
1599
 
------------------------------------------------------------
1600
 
revision-id: 2a
1601
 
committer: Joe Foo <joe@foo.com>
1602
 
branch nick: tree
1603
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1604
 
message:
1605
 
  commit 2a
1606
 
------------------------------------------------------------
1607
 
revno: 1
1608
 
committer: Joe Foo <joe@foo.com>
1609
 
branch nick: tree
1610
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1611
 
message:
1612
 
  commit 1a
1613
 
""",
1614
 
            tree.branch, log.LongLogFormatter, show_log_kwargs={
1615
 
                'start_revision': start_rev, 'end_revision': end_rev
1616
 
            })
1617
 
 
1618
 
    def test_short_format(self):
1619
 
        tree = self.setup_ab_tree()
1620
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
1621
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1622
 
        self.assertFormatterResult("""\
1623
 
      Joe Foo\t2005-11-22
1624
 
      revision-id:3a
1625
 
      commit 3a
1626
 
 
1627
 
      Joe Foo\t2005-11-22
1628
 
      revision-id:2a
1629
 
      commit 2a
1630
 
 
1631
 
    1 Joe Foo\t2005-11-22
1632
 
      commit 1a
1633
 
 
1634
 
""",
1635
 
            tree.branch, log.ShortLogFormatter, show_log_kwargs={
1636
 
                'start_revision': start_rev, 'end_revision': end_rev
1637
 
            })
1638
 
 
1639
 
    def test_line_format(self):
1640
 
        tree = self.setup_ab_tree()
1641
 
        start_rev = revisionspec.RevisionInfo(tree.branch, None, '1a')
1642
 
        end_rev = revisionspec.RevisionInfo(tree.branch, None, '3a')
1643
 
        self.assertFormatterResult("""\
1644
 
Joe Foo 2005-11-22 commit 3a
1645
 
Joe Foo 2005-11-22 commit 2a
1646
 
1: Joe Foo 2005-11-22 commit 1a
1647
 
""",
1648
 
            tree.branch, log.LineLogFormatter, show_log_kwargs={
1649
 
                'start_revision': start_rev, 'end_revision': end_rev
1650
 
            })
1651
 
 
1652
 
 
1653
 
class TestLogWithBugs(TestCaseForLogFormatter, TestLogMixin):
1654
 
 
1655
 
    def setUp(self):
1656
 
        TestCaseForLogFormatter.setUp(self)
1657
 
        log.properties_handler_registry.register(
1658
 
            'bugs_properties_handler',
1659
 
            log._bugs_properties_handler)
1660
 
 
1661
 
    def make_commits_with_bugs(self):
1662
 
        """Helper method for LogFormatter tests"""
1663
 
        tree = self.make_branch_and_tree(u'.')
1664
 
        self.build_tree(['a', 'b'])
1665
 
        tree.add('a')
1666
 
        self.wt_commit(tree, 'simple log message', rev_id='a1',
1667
 
                       revprops={'bugs': 'test://bug/id fixed'})
1668
 
        tree.add('b')
1669
 
        self.wt_commit(tree, 'multiline\nlog\nmessage\n', rev_id='a2',
1670
 
                       authors=['Joe Bar <joe@bar.com>'],
1671
 
                       revprops={'bugs': 'test://bug/id fixed\n'
1672
 
                                 'test://bug/2 fixed'})
1673
 
        return tree
1674
 
 
1675
 
 
1676
 
    def test_long_bugs(self):
1677
 
        tree = self.make_commits_with_bugs()
1678
 
        self.assertFormatterResult("""\
1679
 
------------------------------------------------------------
1680
 
revno: 2
1681
 
fixes bug(s): test://bug/id test://bug/2
1682
 
author: Joe Bar <joe@bar.com>
1683
 
committer: Joe Foo <joe@foo.com>
1684
 
branch nick: work
1685
 
timestamp: Tue 2005-11-22 00:00:01 +0000
1686
 
message:
1687
 
  multiline
1688
 
  log
1689
 
  message
1690
 
------------------------------------------------------------
1691
 
revno: 1
1692
 
fixes bug(s): test://bug/id
1693
 
committer: Joe Foo <joe@foo.com>
1694
 
branch nick: work
1695
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1696
 
message:
1697
 
  simple log message
1698
 
""",
1699
 
            tree.branch, log.LongLogFormatter)
1700
 
 
1701
 
    def test_short_bugs(self):
1702
 
        tree = self.make_commits_with_bugs()
1703
 
        self.assertFormatterResult("""\
1704
 
    2 Joe Bar\t2005-11-22
1705
 
      fixes bug(s): test://bug/id test://bug/2
1706
 
      multiline
1707
 
      log
1708
 
      message
1709
 
 
1710
 
    1 Joe Foo\t2005-11-22
1711
 
      fixes bug(s): test://bug/id
1712
 
      simple log message
1713
 
 
1714
 
""",
1715
 
            tree.branch, log.ShortLogFormatter)
1716
 
 
1717
 
    def test_wrong_bugs_property(self):
1718
 
        tree = self.make_branch_and_tree(u'.')
1719
 
        self.build_tree(['foo'])
1720
 
        self.wt_commit(tree, 'simple log message', rev_id='a1',
1721
 
                       revprops={'bugs': 'test://bug/id invalid_value'})
1722
 
        self.assertFormatterResult("""\
1723
 
    1 Joe Foo\t2005-11-22
1724
 
      simple log message
1725
 
 
1726
 
""",
1727
 
            tree.branch, log.ShortLogFormatter)
1728
 
 
1729
 
    def test_bugs_handler_present(self):
1730
 
        self.properties_handler_registry.get('bugs_properties_handler')
1731
 
 
1732
 
 
1733
 
class TestLogForAuthors(TestCaseForLogFormatter):
1734
 
 
1735
 
    def setUp(self):
1736
 
        TestCaseForLogFormatter.setUp(self)
1737
 
        self.wt = self.make_standard_commit('nicky',
1738
 
            authors=['John Doe <jdoe@example.com>',
1739
 
                     'Jane Rey <jrey@example.com>'])
1740
 
 
1741
 
    def assertFormatterResult(self, formatter, who, result):
1742
 
        formatter_kwargs = dict()
1743
 
        if who is not None:
1744
 
            author_list_handler = log.author_list_registry.get(who)
1745
 
            formatter_kwargs['author_list_handler'] = author_list_handler
1746
 
        TestCaseForLogFormatter.assertFormatterResult(self, result,
1747
 
            self.wt.branch, formatter, formatter_kwargs=formatter_kwargs)
1748
 
 
1749
 
    def test_line_default(self):
1750
 
        self.assertFormatterResult(log.LineLogFormatter, None, """\
1751
 
1: John Doe 2005-11-22 add a
1752
 
""")
1753
 
 
1754
 
    def test_line_committer(self):
1755
 
        self.assertFormatterResult(log.LineLogFormatter, 'committer', """\
1756
 
1: Lorem Ipsum 2005-11-22 add a
1757
 
""")
1758
 
 
1759
 
    def test_line_first(self):
1760
 
        self.assertFormatterResult(log.LineLogFormatter, 'first', """\
1761
 
1: John Doe 2005-11-22 add a
1762
 
""")
1763
 
 
1764
 
    def test_line_all(self):
1765
 
        self.assertFormatterResult(log.LineLogFormatter, 'all', """\
1766
 
1: John Doe, Jane Rey 2005-11-22 add a
1767
 
""")
1768
 
 
1769
 
 
1770
 
    def test_short_default(self):
1771
 
        self.assertFormatterResult(log.ShortLogFormatter, None, """\
1772
 
    1 John Doe\t2005-11-22
1773
 
      add a
1774
 
 
1775
 
""")
1776
 
 
1777
 
    def test_short_committer(self):
1778
 
        self.assertFormatterResult(log.ShortLogFormatter, 'committer', """\
1779
 
    1 Lorem Ipsum\t2005-11-22
1780
 
      add a
1781
 
 
1782
 
""")
1783
 
 
1784
 
    def test_short_first(self):
1785
 
        self.assertFormatterResult(log.ShortLogFormatter, 'first', """\
1786
 
    1 John Doe\t2005-11-22
1787
 
      add a
1788
 
 
1789
 
""")
1790
 
 
1791
 
    def test_short_all(self):
1792
 
        self.assertFormatterResult(log.ShortLogFormatter, 'all', """\
1793
 
    1 John Doe, Jane Rey\t2005-11-22
1794
 
      add a
1795
 
 
1796
 
""")
1797
 
 
1798
 
    def test_long_default(self):
1799
 
        self.assertFormatterResult(log.LongLogFormatter, None, """\
1800
 
------------------------------------------------------------
1801
 
revno: 1
1802
 
author: John Doe <jdoe@example.com>, Jane Rey <jrey@example.com>
1803
 
committer: Lorem Ipsum <test@example.com>
1804
 
branch nick: nicky
1805
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1806
 
message:
1807
 
  add a
1808
 
""")
1809
 
 
1810
 
    def test_long_committer(self):
1811
 
        self.assertFormatterResult(log.LongLogFormatter, 'committer', """\
1812
 
------------------------------------------------------------
1813
 
revno: 1
1814
 
committer: Lorem Ipsum <test@example.com>
1815
 
branch nick: nicky
1816
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1817
 
message:
1818
 
  add a
1819
 
""")
1820
 
 
1821
 
    def test_long_first(self):
1822
 
        self.assertFormatterResult(log.LongLogFormatter, 'first', """\
1823
 
------------------------------------------------------------
1824
 
revno: 1
1825
 
author: John Doe <jdoe@example.com>
1826
 
committer: Lorem Ipsum <test@example.com>
1827
 
branch nick: nicky
1828
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1829
 
message:
1830
 
  add a
1831
 
""")
1832
 
 
1833
 
    def test_long_all(self):
1834
 
        self.assertFormatterResult(log.LongLogFormatter, 'all', """\
1835
 
------------------------------------------------------------
1836
 
revno: 1
1837
 
author: John Doe <jdoe@example.com>, Jane Rey <jrey@example.com>
1838
 
committer: Lorem Ipsum <test@example.com>
1839
 
branch nick: nicky
1840
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1841
 
message:
1842
 
  add a
1843
 
""")
1844
 
 
1845
 
    def test_gnu_changelog_default(self):
1846
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, None, """\
1847
 
2005-11-22  John Doe  <jdoe@example.com>
1848
 
 
1849
 
\tadd a
1850
 
 
1851
 
""")
1852
 
 
1853
 
    def test_gnu_changelog_committer(self):
1854
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'committer', """\
1855
 
2005-11-22  Lorem Ipsum  <test@example.com>
1856
 
 
1857
 
\tadd a
1858
 
 
1859
 
""")
1860
 
 
1861
 
    def test_gnu_changelog_first(self):
1862
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'first', """\
1863
 
2005-11-22  John Doe  <jdoe@example.com>
1864
 
 
1865
 
\tadd a
1866
 
 
1867
 
""")
1868
 
 
1869
 
    def test_gnu_changelog_all(self):
1870
 
        self.assertFormatterResult(log.GnuChangelogLogFormatter, 'all', """\
1871
 
2005-11-22  John Doe  <jdoe@example.com>, Jane Rey  <jrey@example.com>
1872
 
 
1873
 
\tadd a
1874
 
 
1875
 
""")
1876
 
 
1877
 
 
1878
 
class TestLogExcludeAncestry(tests.TestCaseWithTransport):
1879
 
 
1880
 
    def make_branch_with_alternate_ancestries(self, relpath='.'):
1881
 
        # See test_merge_sorted_exclude_ancestry below for the difference with
1882
 
        # bt.per_branch.test_iter_merge_sorted_revision.
1883
 
        # TestIterMergeSortedRevisionsBushyGraph. 
1884
 
        # make_branch_with_alternate_ancestries
1885
 
        # and test_merge_sorted_exclude_ancestry
1886
 
        # See the FIXME in assertLogRevnos too.
1887
 
        builder = branchbuilder.BranchBuilder(self.get_transport(relpath))
1888
 
        # 1
1889
 
        # |\
1890
 
        # 2 \
1891
 
        # |  |
1892
 
        # |  1.1.1
1893
 
        # |  | \
1894
 
        # |  |  1.2.1
1895
 
        # |  | /
1896
 
        # |  1.1.2
1897
 
        # | /
1898
 
        # 3
1899
 
        builder.start_series()
1900
 
        builder.build_snapshot('1', None, [
1901
 
            ('add', ('', 'TREE_ROOT', 'directory', '')),])
1902
 
        builder.build_snapshot('1.1.1', ['1'], [])
1903
 
        builder.build_snapshot('2', ['1'], [])
1904
 
        builder.build_snapshot('1.2.1', ['1.1.1'], [])
1905
 
        builder.build_snapshot('1.1.2', ['1.1.1', '1.2.1'], [])
1906
 
        builder.build_snapshot('3', ['2', '1.1.2'], [])
1907
 
        builder.finish_series()
1908
 
        br = builder.get_branch()
1909
 
        br.lock_read()
1910
 
        self.addCleanup(br.unlock)
1911
 
        return br
1912
 
 
1913
 
    def assertLogRevnos(self, expected_revnos, b, start, end,
1914
 
                        exclude_common_ancestry, generate_merge_revisions=True):
1915
 
        # FIXME: the layering in log makes it hard to test intermediate levels,
1916
 
        # I wish adding filters with their parameters were easier...
1917
 
        # -- vila 20100413
1918
 
        iter_revs = log._calc_view_revisions(
1919
 
            b, start, end, direction='reverse',
1920
 
            generate_merge_revisions=generate_merge_revisions,
1921
 
            exclude_common_ancestry=exclude_common_ancestry)
1922
 
        self.assertEqual(expected_revnos,
1923
 
                         [revid for revid, revno, depth in iter_revs])
1924
 
 
1925
 
    def test_merge_sorted_exclude_ancestry(self):
1926
 
        b = self.make_branch_with_alternate_ancestries()
1927
 
        self.assertLogRevnos(['3', '1.1.2', '1.2.1', '1.1.1', '2', '1'],
1928
 
                             b, '1', '3', exclude_common_ancestry=False)
1929
 
        # '2' is part of the '3' ancestry but not part of '1.1.1' ancestry so
1930
 
        # it should be mentioned even if merge_sort order will make it appear
1931
 
        # after 1.1.1
1932
 
        self.assertLogRevnos(['3', '1.1.2', '1.2.1', '2'],
1933
 
                             b, '1.1.1', '3', exclude_common_ancestry=True)
1934
 
 
1935
 
    def test_merge_sorted_simple_revnos_exclude_ancestry(self):
1936
 
        b = self.make_branch_with_alternate_ancestries()
1937
 
        self.assertLogRevnos(['3', '2'],
1938
 
                             b, '1', '3', exclude_common_ancestry=True,
1939
 
                             generate_merge_revisions=False)
1940
 
        self.assertLogRevnos(['3', '1.1.2', '1.2.1', '1.1.1', '2'],
1941
 
                             b, '1', '3', exclude_common_ancestry=True,
1942
 
                             generate_merge_revisions=True)
1943