← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_log.py

  • Committer: Andrew Bennetts
  • Date: 2008-09-05 10:48:03 UTC
  • mto: This revision was merged to the branch mainline in revision 3693.
  • Revision ID: andrew.bennetts@canonical.com-20080905104803-6g72dz6wcldosfs2
Remove monkey-patching of branch._ensure_real from test_remote.py.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_log.py
1
 
# Copyright (C) 2005 by Canonical Ltd
2
 
# -*- coding: utf-8 -*-
3
 
# vim: encoding=utf-8
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
19
17
import os
20
18
from cStringIO import StringIO
21
19
 
22
 
from bzrlib.tests import BzrTestBase, TestCaseWithTransport
23
 
from bzrlib.log import (LogFormatter, show_log, LongLogFormatter,
24
 
                        ShortLogFormatter, LineLogFormatter)
 
20
from bzrlib import log, registry
 
21
from bzrlib.tests import TestCase, TestCaseWithTransport
 
22
from bzrlib.log import (show_log,
 
23
                        get_view_revisions,
 
24
                        LogRevision,
 
25
                        LogFormatter,
 
26
                        LongLogFormatter,
 
27
                        ShortLogFormatter,
 
28
                        LineLogFormatter)
25
29
from bzrlib.branch import Branch
26
 
from bzrlib.errors import InvalidRevisionNumber
27
 
 
28
 
 
29
 
class _LogEntry(object):
30
 
    # should probably move into bzrlib.log?
31
 
    pass
 
30
from bzrlib.errors import (
 
31
    BzrCommandError,
 
32
    InvalidRevisionNumber,
 
33
    )
 
34
from bzrlib.revision import Revision
 
35
from bzrlib.revisionspec import (
 
36
    RevisionInfo,
 
37
    RevisionSpec,
 
38
    )
 
39
 
 
40
 
 
41
class TestCaseWithoutPropsHandler(TestCaseWithTransport):
 
42
 
 
43
    def setUp(self):
 
44
        super(TestCaseWithoutPropsHandler, self).setUp()
 
45
        # keep a reference to the "current" custom prop. handler registry
 
46
        self.properties_handler_registry = \
 
47
            log.properties_handler_registry
 
48
        # clean up the registry in log
 
49
        log.properties_handler_registry = registry.Registry()
 
50
        
 
51
    def _cleanup(self):
 
52
        super(TestCaseWithoutPropsHandler, self)._cleanup()
 
53
        # restore the custom properties handler registry
 
54
        log.properties_handler_registry = \
 
55
            self.properties_handler_registry
32
56
 
33
57
 
34
58
class LogCatcher(LogFormatter):
40
64
 
41
65
    We should also test the LogFormatter.
42
66
    """
 
67
 
 
68
    supports_delta = True
 
69
 
43
70
    def __init__(self):
44
71
        super(LogCatcher, self).__init__(to_file=None)
45
72
        self.logs = []
46
73
 
47
 
    def show(self, revno, rev, delta):
48
 
        le = _LogEntry()
49
 
        le.revno = revno
50
 
        le.rev = rev
51
 
        le.delta = delta
52
 
        self.logs.append(le)
53
 
 
54
 
 
55
 
class SimpleLogTest(TestCaseWithTransport):
 
74
    def log_revision(self, revision):
 
75
        self.logs.append(revision)
 
76
 
 
77
 
 
78
class TestShowLog(TestCaseWithTransport):
56
79
 
57
80
    def checkDelta(self, delta, **kw):
58
81
        """Check the filenames touched by a delta are as expected."""
59
82
        for n in 'added', 'removed', 'renamed', 'modified', 'unchanged':
60
83
            expected = kw.get(n, [])
61
 
 
62
 
            # tests are written with unix paths; fix them up for windows
63
 
            #if os.sep != '/':
64
 
            #    expected = [x.replace('/', os.sep) for x in expected]
65
 
 
66
84
            # strip out only the path components
67
85
            got = [x[0] for x in getattr(delta, n)]
68
86
            self.assertEquals(expected, got)
87
105
        self.assertRaises(InvalidRevisionNumber, show_log, b, lf,
88
106
                          start_revision=1, end_revision=-1) 
89
107
 
90
 
    def test_cur_revno(self):
91
 
        wt = self.make_branch_and_tree('.')
92
 
        b = wt.branch
93
 
 
94
 
        lf = LogCatcher()
95
 
        wt.commit('empty commit')
96
 
        show_log(b, lf, verbose=True, start_revision=1, end_revision=1)
97
 
        self.assertRaises(InvalidRevisionNumber, show_log, b, lf,
98
 
                          start_revision=2, end_revision=1) 
99
 
        self.assertRaises(InvalidRevisionNumber, show_log, b, lf,
100
 
                          start_revision=1, end_revision=2) 
101
 
        self.assertRaises(InvalidRevisionNumber, show_log, b, lf,
102
 
                          start_revision=0, end_revision=2) 
103
 
        self.assertRaises(InvalidRevisionNumber, show_log, b, lf,
104
 
                          start_revision=1, end_revision=0) 
105
 
        self.assertRaises(InvalidRevisionNumber, show_log, b, lf,
106
 
                          start_revision=-1, end_revision=1) 
107
 
        self.assertRaises(InvalidRevisionNumber, show_log, b, lf,
108
 
                          start_revision=1, end_revision=-1) 
109
 
 
110
108
    def test_simple_log(self):
111
109
        eq = self.assertEquals
112
110
        
122
120
        lf = LogCatcher()
123
121
        show_log(b, lf, verbose=True)
124
122
        eq(len(lf.logs), 1)
125
 
        eq(lf.logs[0].revno, 1)
 
123
        eq(lf.logs[0].revno, '1')
126
124
        eq(lf.logs[0].rev.message, 'empty commit')
127
125
        d = lf.logs[0].delta
128
126
        self.log('log delta: %r' % d)
130
128
 
131
129
        self.build_tree(['hello'])
132
130
        wt.add('hello')
133
 
        wt.commit('add one file')
 
131
        wt.commit('add one file',
 
132
                  committer=u'\u013d\xf3r\xe9m \xcdp\u0161\xfam '
 
133
                            u'<test@example.com>')
134
134
 
135
 
        lf = StringIO()
 
135
        lf = self.make_utf8_encoded_stringio()
136
136
        # log using regular thing
137
137
        show_log(b, LongLogFormatter(lf))
138
138
        lf.seek(0)
145
145
        eq(len(lf.logs), 2)
146
146
        self.log('log entries:')
147
147
        for logentry in lf.logs:
148
 
            self.log('%4d %s' % (logentry.revno, logentry.rev.message))
 
148
            self.log('%4s %s' % (logentry.revno, logentry.rev.message))
149
149
        
150
150
        # first one is most recent
151
151
        logentry = lf.logs[0]
152
 
        eq(logentry.revno, 2)
 
152
        eq(logentry.revno, '2')
153
153
        eq(logentry.rev.message, 'add one file')
154
154
        d = logentry.delta
155
155
        self.log('log 2 delta: %r' % d)
156
 
        # self.checkDelta(d, added=['hello'])
 
156
        self.checkDelta(d, added=['hello'])
157
157
        
158
158
        # commit a log message with control characters
159
159
        msg = "All 8-bit chars: " +  ''.join([unichr(x) for x in range(256)])
180
180
        self.log("escaped commit message: %r", committed_msg)
181
181
        self.assert_(msg == committed_msg)
182
182
 
 
183
    def test_deltas_in_merge_revisions(self):
 
184
        """Check deltas created for both mainline and merge revisions"""
 
185
        eq = self.assertEquals
 
186
        wt = self.make_branch_and_tree('parent')
 
187
        self.build_tree(['parent/file1', 'parent/file2', 'parent/file3'])
 
188
        wt.add('file1')
 
189
        wt.add('file2')
 
190
        wt.commit(message='add file1 and file2')
 
191
        self.run_bzr('branch parent child')
 
192
        os.unlink('child/file1')
 
193
        file('child/file2', 'wb').write('hello\n')
 
194
        self.run_bzr(['commit', '-m', 'remove file1 and modify file2',
 
195
            'child'])
 
196
        os.chdir('parent')
 
197
        self.run_bzr('merge ../child')
 
198
        wt.commit('merge child branch')
 
199
        os.chdir('..')
 
200
        b = wt.branch
 
201
        lf = LogCatcher()
 
202
        lf.supports_merge_revisions = True
 
203
        show_log(b, lf, verbose=True)
 
204
        eq(len(lf.logs),3)
 
205
        logentry = lf.logs[0]
 
206
        eq(logentry.revno, '2')
 
207
        eq(logentry.rev.message, 'merge child branch')
 
208
        d = logentry.delta
 
209
        self.checkDelta(d, removed=['file1'], modified=['file2'])
 
210
        logentry = lf.logs[1]
 
211
        eq(logentry.revno, '1.1.1')
 
212
        eq(logentry.rev.message, 'remove file1 and modify file2')
 
213
        d = logentry.delta
 
214
        self.checkDelta(d, removed=['file1'], modified=['file2'])
 
215
        logentry = lf.logs[2]
 
216
        eq(logentry.revno, '1')
 
217
        eq(logentry.rev.message, 'add file1 and file2')
 
218
        d = logentry.delta
 
219
        self.checkDelta(d, added=['file1', 'file2'])
 
220
 
 
221
    def test_merges_nonsupporting_formatter(self):
 
222
        """Tests that show_log will raise if the formatter doesn't
 
223
        support merge revisions."""
 
224
        wt = self.make_branch_and_memory_tree('.')
 
225
        wt.lock_write()
 
226
        try:
 
227
            wt.add('')
 
228
            wt.commit('rev-1', rev_id='rev-1',
 
229
                      timestamp=1132586655, timezone=36000,
 
230
                      committer='Joe Foo <joe@foo.com>')
 
231
            wt.commit('rev-merged', rev_id='rev-2a',
 
232
                      timestamp=1132586700, timezone=36000,
 
233
                      committer='Joe Foo <joe@foo.com>')
 
234
            wt.set_parent_ids(['rev-1', 'rev-2a'])
 
235
            wt.branch.set_last_revision_info(1, 'rev-1')
 
236
            wt.commit('rev-2', rev_id='rev-2b',
 
237
                      timestamp=1132586800, timezone=36000,
 
238
                      committer='Joe Foo <joe@foo.com>')
 
239
            logfile = self.make_utf8_encoded_stringio()
 
240
            formatter = ShortLogFormatter(to_file=logfile)
 
241
            wtb = wt.branch
 
242
            lf = LogCatcher()
 
243
            revspec = RevisionSpec.from_string('1.1.1')
 
244
            rev = revspec.in_history(wtb)
 
245
            self.assertRaises(BzrCommandError, show_log, wtb, lf,
 
246
                              start_revision=rev, end_revision=rev)
 
247
        finally:
 
248
            wt.unlock()
 
249
 
 
250
 
 
251
def make_commits_with_trailing_newlines(wt):
 
252
    """Helper method for LogFormatter tests"""    
 
253
    b = wt.branch
 
254
    b.nick='test'
 
255
    open('a', 'wb').write('hello moto\n')
 
256
    wt.add('a')
 
257
    wt.commit('simple log message', rev_id='a1',
 
258
              timestamp=1132586655.459960938, timezone=-6*3600,
 
259
              committer='Joe Foo <joe@foo.com>')
 
260
    open('b', 'wb').write('goodbye\n')
 
261
    wt.add('b')
 
262
    wt.commit('multiline\nlog\nmessage\n', rev_id='a2',
 
263
              timestamp=1132586842.411175966, timezone=-6*3600,
 
264
              committer='Joe Foo <joe@foo.com>',
 
265
              author='Joe Bar <joe@bar.com>')
 
266
 
 
267
    open('c', 'wb').write('just another manic monday\n')
 
268
    wt.add('c')
 
269
    wt.commit('single line with trailing newline\n', rev_id='a3',
 
270
              timestamp=1132587176.835228920, timezone=-6*3600,
 
271
              committer = 'Joe Foo <joe@foo.com>')
 
272
    return b
 
273
 
 
274
 
 
275
def normalize_log(log):
 
276
    """Replaces the variable lines of logs with fixed lines"""
 
277
    author = 'author: Dolor Sit <test@example.com>'
 
278
    committer = 'committer: Lorem Ipsum <test@example.com>'
 
279
    lines = log.splitlines(True)
 
280
    for idx,line in enumerate(lines):
 
281
        stripped_line = line.lstrip()
 
282
        indent = ' ' * (len(line) - len(stripped_line))
 
283
        if stripped_line.startswith('author:'):
 
284
            lines[idx] = indent + author + '\n'
 
285
        elif stripped_line.startswith('committer:'):
 
286
            lines[idx] = indent + committer + '\n'
 
287
        elif stripped_line.startswith('timestamp:'):
 
288
            lines[idx] = indent + 'timestamp: Just now\n'
 
289
    return ''.join(lines)
 
290
 
 
291
 
 
292
class TestShortLogFormatter(TestCaseWithTransport):
 
293
 
183
294
    def test_trailing_newlines(self):
184
295
        wt = self.make_branch_and_tree('.')
185
 
        b = wt.branch
186
 
        b.nick='test'
187
 
        open('a', 'wb').write('hello moto\n')
188
 
        wt.add('a')
189
 
        wt.commit('simple log message', rev_id='a1'
190
 
                , timestamp=1132586655.459960938, timezone=-6*3600
191
 
                , committer='Joe Foo <joe@foo.com>')
192
 
        open('b', 'wb').write('goodbye\n')
193
 
        wt.add('b')
194
 
        wt.commit('multiline\nlog\nmessage\n', rev_id='a2'
195
 
                , timestamp=1132586842.411175966, timezone=-6*3600
196
 
                , committer='Joe Foo <joe@foo.com>')
197
 
 
198
 
        open('c', 'wb').write('just another manic monday\n')
199
 
        wt.add('c')
200
 
        wt.commit('single line with trailing newline\n', rev_id='a3'
201
 
                , timestamp=1132587176.835228920, timezone=-6*3600
202
 
                , committer = 'Joe Foo <joe@foo.com>')
203
 
 
204
 
        sio = StringIO()
 
296
        b = make_commits_with_trailing_newlines(wt)
 
297
        sio = self.make_utf8_encoded_stringio()
205
298
        lf = ShortLogFormatter(to_file=sio)
206
299
        show_log(b, lf)
207
 
        self.assertEquals(sio.getvalue(), """\
 
300
        self.assertEqualDiff(sio.getvalue(), """\
208
301
    3 Joe Foo\t2005-11-21
209
302
      single line with trailing newline
210
303
 
211
 
    2 Joe Foo\t2005-11-21
 
304
    2 Joe Bar\t2005-11-21
212
305
      multiline
213
306
      log
214
307
      message
218
311
 
219
312
""")
220
313
 
221
 
        sio = StringIO()
222
 
        lf = LongLogFormatter(to_file=sio)
223
 
        show_log(b, lf)
224
 
        self.assertEquals(sio.getvalue(), """\
225
 
------------------------------------------------------------
226
 
revno: 3
227
 
committer: Joe Foo <joe@foo.com>
228
 
branch nick: test
229
 
timestamp: Mon 2005-11-21 09:32:56 -0600
230
 
message:
231
 
  single line with trailing newline
232
 
------------------------------------------------------------
233
 
revno: 2
234
 
committer: Joe Foo <joe@foo.com>
235
 
branch nick: test
236
 
timestamp: Mon 2005-11-21 09:27:22 -0600
237
 
message:
238
 
  multiline
239
 
  log
240
 
  message
241
 
------------------------------------------------------------
242
 
revno: 1
243
 
committer: Joe Foo <joe@foo.com>
244
 
branch nick: test
245
 
timestamp: Mon 2005-11-21 09:24:15 -0600
246
 
message:
247
 
  simple log message
248
 
""")
249
 
        
 
314
    def test_short_log_with_merges(self):
 
315
        wt = self.make_branch_and_memory_tree('.')
 
316
        wt.lock_write()
 
317
        try:
 
318
            wt.add('')
 
319
            wt.commit('rev-1', rev_id='rev-1',
 
320
                      timestamp=1132586655, timezone=36000,
 
321
                      committer='Joe Foo <joe@foo.com>')
 
322
            wt.commit('rev-merged', rev_id='rev-2a',
 
323
                      timestamp=1132586700, timezone=36000,
 
324
                      committer='Joe Foo <joe@foo.com>')
 
325
            wt.set_parent_ids(['rev-1', 'rev-2a'])
 
326
            wt.branch.set_last_revision_info(1, 'rev-1')
 
327
            wt.commit('rev-2', rev_id='rev-2b',
 
328
                      timestamp=1132586800, timezone=36000,
 
329
                      committer='Joe Foo <joe@foo.com>')
 
330
            logfile = self.make_utf8_encoded_stringio()
 
331
            formatter = ShortLogFormatter(to_file=logfile)
 
332
            show_log(wt.branch, formatter)
 
333
            self.assertEqualDiff(logfile.getvalue(), """\
 
334
    2 Joe Foo\t2005-11-22 [merge]
 
335
      rev-2
 
336
 
 
337
    1 Joe Foo\t2005-11-22
 
338
      rev-1
 
339
 
 
340
""")
 
341
        finally:
 
342
            wt.unlock()
 
343
 
 
344
    def test_short_log_single_merge_revision(self):
 
345
        wt = self.make_branch_and_memory_tree('.')
 
346
        wt.lock_write()
 
347
        try:
 
348
            wt.add('')
 
349
            wt.commit('rev-1', rev_id='rev-1',
 
350
                      timestamp=1132586655, timezone=36000,
 
351
                      committer='Joe Foo <joe@foo.com>')
 
352
            wt.commit('rev-merged', rev_id='rev-2a',
 
353
                      timestamp=1132586700, timezone=36000,
 
354
                      committer='Joe Foo <joe@foo.com>')
 
355
            wt.set_parent_ids(['rev-1', 'rev-2a'])
 
356
            wt.branch.set_last_revision_info(1, 'rev-1')
 
357
            wt.commit('rev-2', rev_id='rev-2b',
 
358
                      timestamp=1132586800, timezone=36000,
 
359
                      committer='Joe Foo <joe@foo.com>')
 
360
            logfile = self.make_utf8_encoded_stringio()
 
361
            formatter = ShortLogFormatter(to_file=logfile)
 
362
            revspec = RevisionSpec.from_string('1.1.1')
 
363
            wtb = wt.branch
 
364
            rev = revspec.in_history(wtb)
 
365
            show_log(wtb, formatter, start_revision=rev, end_revision=rev)
 
366
            self.assertEqualDiff(logfile.getvalue(), """\
 
367
1.1.1 Joe Foo\t2005-11-22
 
368
      rev-merged
 
369
 
 
370
""")
 
371
        finally:
 
372
            wt.unlock()
 
373
 
 
374
 
 
375
class TestLongLogFormatter(TestCaseWithoutPropsHandler):
 
376
 
250
377
    def test_verbose_log(self):
251
378
        """Verbose log includes changed files
252
379
        
280
407
  a
281
408
''')
282
409
 
 
410
    def test_merges_are_indented_by_level(self):
 
411
        wt = self.make_branch_and_tree('parent')
 
412
        wt.commit('first post')
 
413
        self.run_bzr('branch parent child')
 
414
        self.run_bzr(['commit', '-m', 'branch 1', '--unchanged', 'child'])
 
415
        self.run_bzr('branch child smallerchild')
 
416
        self.run_bzr(['commit', '-m', 'branch 2', '--unchanged',
 
417
            'smallerchild'])
 
418
        os.chdir('child')
 
419
        self.run_bzr('merge ../smallerchild')
 
420
        self.run_bzr(['commit', '-m', 'merge branch 2'])
 
421
        os.chdir('../parent')
 
422
        self.run_bzr('merge ../child')
 
423
        wt.commit('merge branch 1')
 
424
        b = wt.branch
 
425
        sio = self.make_utf8_encoded_stringio()
 
426
        lf = LongLogFormatter(to_file=sio)
 
427
        show_log(b, lf, verbose=True)
 
428
        log = normalize_log(sio.getvalue())
 
429
        self.assertEqualDiff(log, """\
 
430
------------------------------------------------------------
 
431
revno: 2
 
432
committer: Lorem Ipsum <test@example.com>
 
433
branch nick: parent
 
434
timestamp: Just now
 
435
message:
 
436
  merge branch 1
 
437
    ------------------------------------------------------------
 
438
    revno: 1.1.2
 
439
    committer: Lorem Ipsum <test@example.com>
 
440
    branch nick: child
 
441
    timestamp: Just now
 
442
    message:
 
443
      merge branch 2
 
444
        ------------------------------------------------------------
 
445
        revno: 1.2.1
 
446
        committer: Lorem Ipsum <test@example.com>
 
447
        branch nick: smallerchild
 
448
        timestamp: Just now
 
449
        message:
 
450
          branch 2
 
451
    ------------------------------------------------------------
 
452
    revno: 1.1.1
 
453
    committer: Lorem Ipsum <test@example.com>
 
454
    branch nick: child
 
455
    timestamp: Just now
 
456
    message:
 
457
      branch 1
 
458
------------------------------------------------------------
 
459
revno: 1
 
460
committer: Lorem Ipsum <test@example.com>
 
461
branch nick: parent
 
462
timestamp: Just now
 
463
message:
 
464
  first post
 
465
""")
 
466
 
 
467
    def test_verbose_merge_revisions_contain_deltas(self):
 
468
        wt = self.make_branch_and_tree('parent')
 
469
        self.build_tree(['parent/f1', 'parent/f2'])
 
470
        wt.add(['f1','f2'])
 
471
        wt.commit('first post')
 
472
        self.run_bzr('branch parent child')
 
473
        os.unlink('child/f1')
 
474
        file('child/f2', 'wb').write('hello\n')
 
475
        self.run_bzr(['commit', '-m', 'removed f1 and modified f2',
 
476
            'child'])
 
477
        os.chdir('parent')
 
478
        self.run_bzr('merge ../child')
 
479
        wt.commit('merge branch 1')
 
480
        b = wt.branch
 
481
        sio = self.make_utf8_encoded_stringio()
 
482
        lf = LongLogFormatter(to_file=sio)
 
483
        show_log(b, lf, verbose=True)
 
484
        log = normalize_log(sio.getvalue())
 
485
        self.assertEqualDiff(log, """\
 
486
------------------------------------------------------------
 
487
revno: 2
 
488
committer: Lorem Ipsum <test@example.com>
 
489
branch nick: parent
 
490
timestamp: Just now
 
491
message:
 
492
  merge branch 1
 
493
removed:
 
494
  f1
 
495
modified:
 
496
  f2
 
497
    ------------------------------------------------------------
 
498
    revno: 1.1.1
 
499
    committer: Lorem Ipsum <test@example.com>
 
500
    branch nick: child
 
501
    timestamp: Just now
 
502
    message:
 
503
      removed f1 and modified f2
 
504
    removed:
 
505
      f1
 
506
    modified:
 
507
      f2
 
508
------------------------------------------------------------
 
509
revno: 1
 
510
committer: Lorem Ipsum <test@example.com>
 
511
branch nick: parent
 
512
timestamp: Just now
 
513
message:
 
514
  first post
 
515
added:
 
516
  f1
 
517
  f2
 
518
""")
 
519
 
 
520
    def test_trailing_newlines(self):
 
521
        wt = self.make_branch_and_tree('.')
 
522
        b = make_commits_with_trailing_newlines(wt)
 
523
        sio = self.make_utf8_encoded_stringio()
 
524
        lf = LongLogFormatter(to_file=sio)
 
525
        show_log(b, lf)
 
526
        self.assertEqualDiff(sio.getvalue(), """\
 
527
------------------------------------------------------------
 
528
revno: 3
 
529
committer: Joe Foo <joe@foo.com>
 
530
branch nick: test
 
531
timestamp: Mon 2005-11-21 09:32:56 -0600
 
532
message:
 
533
  single line with trailing newline
 
534
------------------------------------------------------------
 
535
revno: 2
 
536
author: Joe Bar <joe@bar.com>
 
537
committer: Joe Foo <joe@foo.com>
 
538
branch nick: test
 
539
timestamp: Mon 2005-11-21 09:27:22 -0600
 
540
message:
 
541
  multiline
 
542
  log
 
543
  message
 
544
------------------------------------------------------------
 
545
revno: 1
 
546
committer: Joe Foo <joe@foo.com>
 
547
branch nick: test
 
548
timestamp: Mon 2005-11-21 09:24:15 -0600
 
549
message:
 
550
  simple log message
 
551
""")
 
552
 
 
553
    def test_author_in_log(self):
 
554
        """Log includes the author name if it's set in
 
555
        the revision properties
 
556
        """
 
557
        wt = self.make_branch_and_tree('.')
 
558
        b = wt.branch
 
559
        self.build_tree(['a'])
 
560
        wt.add('a')
 
561
        b.nick = 'test_author_log'
 
562
        wt.commit(message='add a',
 
563
                  timestamp=1132711707,
 
564
                  timezone=36000,
 
565
                  committer='Lorem Ipsum <test@example.com>',
 
566
                  author='John Doe <jdoe@example.com>')
 
567
        sio = StringIO()
 
568
        formatter = LongLogFormatter(to_file=sio)
 
569
        show_log(b, formatter)
 
570
        self.assertEqualDiff(sio.getvalue(), '''\
 
571
------------------------------------------------------------
 
572
revno: 1
 
573
author: John Doe <jdoe@example.com>
 
574
committer: Lorem Ipsum <test@example.com>
 
575
branch nick: test_author_log
 
576
timestamp: Wed 2005-11-23 12:08:27 +1000
 
577
message:
 
578
  add a
 
579
''')
 
580
 
 
581
    def test_properties_in_log(self):
 
582
        """Log includes the custom properties returned by the registered 
 
583
        handlers.
 
584
        """
 
585
        wt = self.make_branch_and_tree('.')
 
586
        b = wt.branch
 
587
        self.build_tree(['a'])
 
588
        wt.add('a')
 
589
        b.nick = 'test_properties_in_log'
 
590
        wt.commit(message='add a',
 
591
                  timestamp=1132711707,
 
592
                  timezone=36000,
 
593
                  committer='Lorem Ipsum <test@example.com>',
 
594
                  author='John Doe <jdoe@example.com>')
 
595
        sio = StringIO()
 
596
        formatter = LongLogFormatter(to_file=sio)
 
597
        try:
 
598
            def trivial_custom_prop_handler(revision):
 
599
                return {'test_prop':'test_value'}
 
600
            
 
601
            log.properties_handler_registry.register(
 
602
                'trivial_custom_prop_handler', 
 
603
                trivial_custom_prop_handler)
 
604
            show_log(b, formatter)
 
605
        finally:
 
606
            log.properties_handler_registry.remove(
 
607
                'trivial_custom_prop_handler')
 
608
            self.assertEqualDiff(sio.getvalue(), '''\
 
609
------------------------------------------------------------
 
610
revno: 1
 
611
test_prop: test_value
 
612
author: John Doe <jdoe@example.com>
 
613
committer: Lorem Ipsum <test@example.com>
 
614
branch nick: test_properties_in_log
 
615
timestamp: Wed 2005-11-23 12:08:27 +1000
 
616
message:
 
617
  add a
 
618
''')
 
619
 
 
620
    def test_error_in_properties_handler(self):
 
621
        """Log includes the custom properties returned by the registered 
 
622
        handlers.
 
623
        """
 
624
        wt = self.make_branch_and_tree('.')
 
625
        b = wt.branch
 
626
        self.build_tree(['a'])
 
627
        wt.add('a')
 
628
        b.nick = 'test_author_log'
 
629
        wt.commit(message='add a',
 
630
                  timestamp=1132711707,
 
631
                  timezone=36000,
 
632
                  committer='Lorem Ipsum <test@example.com>',
 
633
                  author='John Doe <jdoe@example.com>',
 
634
                  revprops={'first_prop':'first_value'})
 
635
        sio = StringIO()
 
636
        formatter = LongLogFormatter(to_file=sio)
 
637
        try:
 
638
            def trivial_custom_prop_handler(revision):
 
639
                raise StandardError("a test error")
 
640
            
 
641
            log.properties_handler_registry.register(
 
642
                'trivial_custom_prop_handler', 
 
643
                trivial_custom_prop_handler)
 
644
            self.assertRaises(StandardError, show_log, b, formatter,)
 
645
        finally:
 
646
            log.properties_handler_registry.remove(
 
647
                'trivial_custom_prop_handler')
 
648
                
 
649
    def test_properties_handler_bad_argument(self):
 
650
        wt = self.make_branch_and_tree('.')
 
651
        b = wt.branch
 
652
        self.build_tree(['a'])
 
653
        wt.add('a')
 
654
        b.nick = 'test_author_log'
 
655
        wt.commit(message='add a',
 
656
                  timestamp=1132711707,
 
657
                  timezone=36000,
 
658
                  committer='Lorem Ipsum <test@example.com>',
 
659
                  author='John Doe <jdoe@example.com>',
 
660
                  revprops={'a_prop':'test_value'})
 
661
        sio = StringIO()
 
662
        formatter = LongLogFormatter(to_file=sio)
 
663
        try:
 
664
            def bad_argument_prop_handler(revision):
 
665
                return {'custom_prop_name':revision.properties['a_prop']}
 
666
                
 
667
            log.properties_handler_registry.register(
 
668
                'bad_argument_prop_handler', 
 
669
                bad_argument_prop_handler)
 
670
            
 
671
            self.assertRaises(AttributeError, formatter.show_properties, 
 
672
                'a revision', '')
 
673
            
 
674
            revision = b.repository.get_revision(b.last_revision())
 
675
            formatter.show_properties(revision, '')
 
676
            self.assertEqualDiff(sio.getvalue(),
 
677
                '''custom_prop_name: test_value\n''')
 
678
        finally:
 
679
            log.properties_handler_registry.remove(
 
680
                'bad_argument_prop_handler')
 
681
 
 
682
 
 
683
class TestLineLogFormatter(TestCaseWithTransport):
 
684
 
283
685
    def test_line_log(self):
284
686
        """Line log should show revno
285
687
        
290
692
        self.build_tree(['a'])
291
693
        wt.add('a')
292
694
        b.nick = 'test-line-log'
293
 
        wt.commit(message='add a', 
294
 
                  timestamp=1132711707, 
 
695
        wt.commit(message='add a',
 
696
                  timestamp=1132711707,
295
697
                  timezone=36000,
296
698
                  committer='Line-Log-Formatter Tester <test@line.log>')
297
699
        logfile = file('out.tmp', 'w+')
300
702
        logfile.flush()
301
703
        logfile.seek(0)
302
704
        log_contents = logfile.read()
303
 
        self.assertEqualDiff(log_contents, '1: Line-Log-Formatte... 2005-11-23 add a\n')
 
705
        self.assertEqualDiff(log_contents,
 
706
            '1: Line-Log-Formatte... 2005-11-23 add a\n')
 
707
 
 
708
    def test_trailing_newlines(self):
 
709
        wt = self.make_branch_and_tree('.')
 
710
        b = make_commits_with_trailing_newlines(wt)
 
711
        sio = self.make_utf8_encoded_stringio()
 
712
        lf = LineLogFormatter(to_file=sio)
 
713
        show_log(b, lf)
 
714
        self.assertEqualDiff(sio.getvalue(), """\
 
715
3: Joe Foo 2005-11-21 single line with trailing newline
 
716
2: Joe Bar 2005-11-21 multiline
 
717
1: Joe Foo 2005-11-21 simple log message
 
718
""")
 
719
 
 
720
    def test_line_log_single_merge_revision(self):
 
721
        wt = self.make_branch_and_memory_tree('.')
 
722
        wt.lock_write()
 
723
        try:
 
724
            wt.add('')
 
725
            wt.commit('rev-1', rev_id='rev-1',
 
726
                      timestamp=1132586655, timezone=36000,
 
727
                      committer='Joe Foo <joe@foo.com>')
 
728
            wt.commit('rev-merged', rev_id='rev-2a',
 
729
                      timestamp=1132586700, timezone=36000,
 
730
                      committer='Joe Foo <joe@foo.com>')
 
731
            wt.set_parent_ids(['rev-1', 'rev-2a'])
 
732
            wt.branch.set_last_revision_info(1, 'rev-1')
 
733
            wt.commit('rev-2', rev_id='rev-2b',
 
734
                      timestamp=1132586800, timezone=36000,
 
735
                      committer='Joe Foo <joe@foo.com>')
 
736
            logfile = self.make_utf8_encoded_stringio()
 
737
            formatter = LineLogFormatter(to_file=logfile)
 
738
            revspec = RevisionSpec.from_string('1.1.1')
 
739
            wtb = wt.branch
 
740
            rev = revspec.in_history(wtb)
 
741
            show_log(wtb, formatter, start_revision=rev, end_revision=rev)
 
742
            self.assertEqualDiff(logfile.getvalue(), """\
 
743
1.1.1: Joe Foo 2005-11-22 rev-merged
 
744
""")
 
745
        finally:
 
746
            wt.unlock()
 
747
 
 
748
 
 
749
 
 
750
class TestGetViewRevisions(TestCaseWithTransport):
 
751
 
 
752
    def make_tree_with_commits(self):
 
753
        """Create a tree with well-known revision ids"""
 
754
        wt = self.make_branch_and_tree('tree1')
 
755
        wt.commit('commit one', rev_id='1')
 
756
        wt.commit('commit two', rev_id='2')
 
757
        wt.commit('commit three', rev_id='3')
 
758
        mainline_revs = [None, '1', '2', '3']
 
759
        rev_nos = {'1': 1, '2': 2, '3': 3}
 
760
        return mainline_revs, rev_nos, wt
 
761
 
 
762
    def make_tree_with_merges(self):
 
763
        """Create a tree with well-known revision ids and a merge"""
 
764
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
 
765
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
 
766
        tree2.commit('four-a', rev_id='4a')
 
767
        wt.merge_from_branch(tree2.branch)
 
768
        wt.commit('four-b', rev_id='4b')
 
769
        mainline_revs.append('4b')
 
770
        rev_nos['4b'] = 4
 
771
        # 4a: 3.1.1
 
772
        return mainline_revs, rev_nos, wt
 
773
 
 
774
    def make_tree_with_many_merges(self):
 
775
        """Create a tree with well-known revision ids"""
 
776
        wt = self.make_branch_and_tree('tree1')
 
777
        wt.commit('commit one', rev_id='1')
 
778
        wt.commit('commit two', rev_id='2')
 
779
        tree3 = wt.bzrdir.sprout('tree3').open_workingtree()
 
780
        tree3.commit('commit three a', rev_id='3a')
 
781
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
 
782
        tree2.merge_from_branch(tree3.branch)
 
783
        tree2.commit('commit three b', rev_id='3b')
 
784
        wt.merge_from_branch(tree2.branch)
 
785
        wt.commit('commit three c', rev_id='3c')
 
786
        tree2.commit('four-a', rev_id='4a')
 
787
        wt.merge_from_branch(tree2.branch)
 
788
        wt.commit('four-b', rev_id='4b')
 
789
        mainline_revs = [None, '1', '2', '3c', '4b']
 
790
        rev_nos = {'1':1, '2':2, '3c': 3, '4b':4}
 
791
        full_rev_nos_for_reference = {
 
792
            '1': '1',
 
793
            '2': '2',
 
794
            '3a': '2.1.1', #first commit tree 3
 
795
            '3b': '2.2.1', # first commit tree 2
 
796
            '3c': '3', #merges 3b to main
 
797
            '4a': '2.2.2', # second commit tree 2
 
798
            '4b': '4', # merges 4a to main
 
799
            }
 
800
        return mainline_revs, rev_nos, wt
 
801
 
 
802
    def test_get_view_revisions_forward(self):
 
803
        """Test the get_view_revisions method"""
 
804
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
 
805
        wt.lock_read()
 
806
        self.addCleanup(wt.unlock)
 
807
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
 
808
                                            'forward'))
 
809
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0)],
 
810
            revisions)
 
811
        revisions2 = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
 
812
                                             'forward', include_merges=False))
 
813
        self.assertEqual(revisions, revisions2)
 
814
 
 
815
    def test_get_view_revisions_reverse(self):
 
816
        """Test the get_view_revisions with reverse"""
 
817
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
 
818
        wt.lock_read()
 
819
        self.addCleanup(wt.unlock)
 
820
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
 
821
                                            'reverse'))
 
822
        self.assertEqual([('3', '3', 0), ('2', '2', 0), ('1', '1', 0), ],
 
823
            revisions)
 
824
        revisions2 = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
 
825
                                             'reverse', include_merges=False))
 
826
        self.assertEqual(revisions, revisions2)
 
827
 
 
828
    def test_get_view_revisions_merge(self):
 
829
        """Test get_view_revisions when there are merges"""
 
830
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
 
831
        wt.lock_read()
 
832
        self.addCleanup(wt.unlock)
 
833
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
 
834
                                            'forward'))
 
835
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0),
 
836
            ('4b', '4', 0), ('4a', '3.1.1', 1)],
 
837
            revisions)
 
838
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
 
839
                                             'forward', include_merges=False))
 
840
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0),
 
841
            ('4b', '4', 0)],
 
842
            revisions)
 
843
 
 
844
    def test_get_view_revisions_merge_reverse(self):
 
845
        """Test get_view_revisions in reverse when there are merges"""
 
846
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
 
847
        wt.lock_read()
 
848
        self.addCleanup(wt.unlock)
 
849
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
 
850
                                            'reverse'))
 
851
        self.assertEqual([('4b', '4', 0), ('4a', '3.1.1', 1),
 
852
            ('3', '3', 0), ('2', '2', 0), ('1', '1', 0)],
 
853
            revisions)
 
854
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
 
855
                                             'reverse', include_merges=False))
 
856
        self.assertEqual([('4b', '4', 0), ('3', '3', 0), ('2', '2', 0),
 
857
            ('1', '1', 0)],
 
858
            revisions)
 
859
 
 
860
    def test_get_view_revisions_merge2(self):
 
861
        """Test get_view_revisions when there are merges"""
 
862
        mainline_revs, rev_nos, wt = self.make_tree_with_many_merges()
 
863
        wt.lock_read()
 
864
        self.addCleanup(wt.unlock)
 
865
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
 
866
                                            'forward'))
 
867
        expected = [('1', '1', 0), ('2', '2', 0), ('3c', '3', 0),
 
868
            ('3a', '2.1.1', 1), ('3b', '2.2.1', 1), ('4b', '4', 0),
 
869
            ('4a', '2.2.2', 1)]
 
870
        self.assertEqual(expected, revisions)
 
871
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
 
872
                                             'forward', include_merges=False))
 
873
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3c', '3', 0),
 
874
            ('4b', '4', 0)],
 
875
            revisions)
 
876
 
 
877
 
 
878
class TestGetRevisionsTouchingFileID(TestCaseWithTransport):
 
879
 
 
880
    def create_tree_with_single_merge(self):
 
881
        """Create a branch with a moderate layout.
 
882
 
 
883
        The revision graph looks like:
 
884
 
 
885
           A
 
886
           |\
 
887
           B C
 
888
           |/
 
889
           D
 
890
 
 
891
        In this graph, A introduced files f1 and f2 and f3.
 
892
        B modifies f1 and f3, and C modifies f2 and f3.
 
893
        D merges the changes from B and C and resolves the conflict for f3.
 
894
        """
 
895
        # TODO: jam 20070218 This seems like it could really be done
 
896
        #       with make_branch_and_memory_tree() if we could just
 
897
        #       create the content of those files.
 
898
        # TODO: jam 20070218 Another alternative is that we would really
 
899
        #       like to only create this tree 1 time for all tests that
 
900
        #       use it. Since 'log' only uses the tree in a readonly
 
901
        #       fashion, it seems a shame to regenerate an identical
 
902
        #       tree for each test.
 
903
        tree = self.make_branch_and_tree('tree')
 
904
        tree.lock_write()
 
905
        self.addCleanup(tree.unlock)
 
906
 
 
907
        self.build_tree_contents([('tree/f1', 'A\n'),
 
908
                                  ('tree/f2', 'A\n'),
 
909
                                  ('tree/f3', 'A\n'),
 
910
                                 ])
 
911
        tree.add(['f1', 'f2', 'f3'], ['f1-id', 'f2-id', 'f3-id'])
 
912
        tree.commit('A', rev_id='A')
 
913
 
 
914
        self.build_tree_contents([('tree/f2', 'A\nC\n'),
 
915
                                  ('tree/f3', 'A\nC\n'),
 
916
                                 ])
 
917
        tree.commit('C', rev_id='C')
 
918
        # Revert back to A to build the other history.
 
919
        tree.set_last_revision('A')
 
920
        tree.branch.set_last_revision_info(1, 'A')
 
921
        self.build_tree_contents([('tree/f1', 'A\nB\n'),
 
922
                                  ('tree/f2', 'A\n'),
 
923
                                  ('tree/f3', 'A\nB\n'),
 
924
                                 ])
 
925
        tree.commit('B', rev_id='B')
 
926
        tree.set_parent_ids(['B', 'C'])
 
927
        self.build_tree_contents([('tree/f1', 'A\nB\n'),
 
928
                                  ('tree/f2', 'A\nC\n'),
 
929
                                  ('tree/f3', 'A\nB\nC\n'),
 
930
                                 ])
 
931
        tree.commit('D', rev_id='D')
 
932
 
 
933
        # Switch to a read lock for this tree.
 
934
        # We still have addCleanup(unlock)
 
935
        tree.unlock()
 
936
        tree.lock_read()
 
937
        return tree
 
938
 
 
939
    def test_tree_with_single_merge(self):
 
940
        """Make sure the tree layout is correct."""
 
941
        tree = self.create_tree_with_single_merge()
 
942
        rev_A_tree = tree.branch.repository.revision_tree('A')
 
943
        rev_B_tree = tree.branch.repository.revision_tree('B')
 
944
 
 
945
        f1_changed = (u'f1', 'f1-id', 'file', True, False)
 
946
        f2_changed = (u'f2', 'f2-id', 'file', True, False)
 
947
        f3_changed = (u'f3', 'f3-id', 'file', True, False)
 
948
 
 
949
        delta = rev_B_tree.changes_from(rev_A_tree)
 
950
        self.assertEqual([f1_changed, f3_changed], delta.modified)
 
951
        self.assertEqual([], delta.renamed)
 
952
        self.assertEqual([], delta.added)
 
953
        self.assertEqual([], delta.removed)
 
954
 
 
955
        rev_C_tree = tree.branch.repository.revision_tree('C')
 
956
        delta = rev_C_tree.changes_from(rev_A_tree)
 
957
        self.assertEqual([f2_changed, f3_changed], delta.modified)
 
958
        self.assertEqual([], delta.renamed)
 
959
        self.assertEqual([], delta.added)
 
960
        self.assertEqual([], delta.removed)
 
961
 
 
962
        rev_D_tree = tree.branch.repository.revision_tree('D')
 
963
        delta = rev_D_tree.changes_from(rev_B_tree)
 
964
        self.assertEqual([f2_changed, f3_changed], delta.modified)
 
965
        self.assertEqual([], delta.renamed)
 
966
        self.assertEqual([], delta.added)
 
967
        self.assertEqual([], delta.removed)
 
968
 
 
969
        delta = rev_D_tree.changes_from(rev_C_tree)
 
970
        self.assertEqual([f1_changed, f3_changed], delta.modified)
 
971
        self.assertEqual([], delta.renamed)
 
972
        self.assertEqual([], delta.added)
 
973
        self.assertEqual([], delta.removed)
 
974
 
 
975
    def assertAllRevisionsForFileID(self, tree, file_id, revisions):
 
976
        """Make sure _filter_revisions_touching_file_id returns the right values.
 
977
 
 
978
        Get the return value from _filter_revisions_touching_file_id and make
 
979
        sure they are correct.
 
980
        """
 
981
        # The api for _get_revisions_touching_file_id is a little crazy,
 
982
        # So we do the setup here.
 
983
        mainline = tree.branch.revision_history()
 
984
        mainline.insert(0, None)
 
985
        revnos = dict((rev, idx+1) for idx, rev in enumerate(mainline))
 
986
        view_revs_iter = log.get_view_revisions(mainline, revnos, tree.branch,
 
987
                                                'reverse', True)
 
988
        actual_revs = log._filter_revisions_touching_file_id(
 
989
                            tree.branch, 
 
990
                            file_id,
 
991
                            mainline,
 
992
                            list(view_revs_iter))
 
993
        self.assertEqual(revisions, [r for r, revno, depth in actual_revs])
 
994
 
 
995
    def test_file_id_f1(self):
 
996
        tree = self.create_tree_with_single_merge()
 
997
        # f1 should be marked as modified by revisions A and B
 
998
        self.assertAllRevisionsForFileID(tree, 'f1-id', ['B', 'A'])
 
999
 
 
1000
    def test_file_id_f2(self):
 
1001
        tree = self.create_tree_with_single_merge()
 
1002
        # f2 should be marked as modified by revisions A, C, and D
 
1003
        # because D merged the changes from C.
 
1004
        self.assertAllRevisionsForFileID(tree, 'f2-id', ['D', 'C', 'A'])
 
1005
 
 
1006
    def test_file_id_f3(self):
 
1007
        tree = self.create_tree_with_single_merge()
 
1008
        # f3 should be marked as modified by revisions A, B, C, and D
 
1009
        self.assertAllRevisionsForFileID(tree, 'f2-id', ['D', 'C', 'A'])
 
1010
 
 
1011
    def test_file_id_with_ghosts(self):
 
1012
        # This is testing bug #209948, where having a ghost would cause
 
1013
        # _filter_revisions_touching_file_id() to fail.
 
1014
        tree = self.create_tree_with_single_merge()
 
1015
        # We need to add a revision, so switch back to a write-locked tree
 
1016
        tree.unlock()
 
1017
        tree.lock_write()
 
1018
        first_parent = tree.last_revision()
 
1019
        tree.set_parent_ids([first_parent, 'ghost-revision-id'])
 
1020
        self.build_tree_contents([('tree/f1', 'A\nB\nXX\n')])
 
1021
        tree.commit('commit with a ghost', rev_id='XX')
 
1022
        self.assertAllRevisionsForFileID(tree, 'f1-id', ['XX', 'B', 'A'])
 
1023
        self.assertAllRevisionsForFileID(tree, 'f2-id', ['D', 'C', 'A'])
 
1024
 
 
1025
 
 
1026
class TestShowChangedRevisions(TestCaseWithTransport):
 
1027
 
 
1028
    def test_show_changed_revisions_verbose(self):
 
1029
        tree = self.make_branch_and_tree('tree_a')
 
1030
        self.build_tree(['tree_a/foo'])
 
1031
        tree.add('foo')
 
1032
        tree.commit('bar', rev_id='bar-id')
 
1033
        s = self.make_utf8_encoded_stringio()
 
1034
        log.show_changed_revisions(tree.branch, [], ['bar-id'], s)
 
1035
        self.assertContainsRe(s.getvalue(), 'bar')
 
1036
        self.assertNotContainsRe(s.getvalue(), 'foo')
 
1037
 
 
1038
 
 
1039
class TestLogFormatter(TestCase):
 
1040
 
 
1041
    def test_short_committer(self):
 
1042
        rev = Revision('a-id')
 
1043
        rev.committer = 'John Doe <jdoe@example.com>'
 
1044
        lf = LogFormatter(None)
 
1045
        self.assertEqual('John Doe', lf.short_committer(rev))
 
1046
        rev.committer = 'John Smith <jsmith@example.com>'
 
1047
        self.assertEqual('John Smith', lf.short_committer(rev))
 
1048
        rev.committer = 'John Smith'
 
1049
        self.assertEqual('John Smith', lf.short_committer(rev))
 
1050
        rev.committer = 'jsmith@example.com'
 
1051
        self.assertEqual('jsmith@example.com', lf.short_committer(rev))
 
1052
        rev.committer = '<jsmith@example.com>'
 
1053
        self.assertEqual('jsmith@example.com', lf.short_committer(rev))
 
1054
        rev.committer = 'John Smith jsmith@example.com'
 
1055
        self.assertEqual('John Smith', lf.short_committer(rev))
 
1056
 
 
1057
    def test_short_author(self):
 
1058
        rev = Revision('a-id')
 
1059
        rev.committer = 'John Doe <jdoe@example.com>'
 
1060
        lf = LogFormatter(None)
 
1061
        self.assertEqual('John Doe', lf.short_author(rev))
 
1062
        rev.properties['author'] = 'John Smith <jsmith@example.com>'
 
1063
        self.assertEqual('John Smith', lf.short_author(rev))
 
1064
        rev.properties['author'] = 'John Smith'
 
1065
        self.assertEqual('John Smith', lf.short_author(rev))
 
1066
        rev.properties['author'] = 'jsmith@example.com'
 
1067
        self.assertEqual('jsmith@example.com', lf.short_author(rev))
 
1068
        rev.properties['author'] = '<jsmith@example.com>'
 
1069
        self.assertEqual('jsmith@example.com', lf.short_author(rev))
 
1070
        rev.properties['author'] = 'John Smith jsmith@example.com'
 
1071
        self.assertEqual('John Smith', lf.short_author(rev))