← 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: Aaron Bentley
  • Date: 2007-02-06 14:52:16 UTC
  • mfrom: (2266 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2268.
  • Revision ID: abentley@panoramicfeedback.com-20070206145216-fcpi8o3ufvuzwbp9
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_log.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
# -*- coding: utf-8 -*-
 
3
# vim: encoding=utf-8
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
17
19
import os
18
20
from cStringIO import StringIO
19
21
 
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,
 
22
from bzrlib.tests import BzrTestBase, TestCaseWithTransport
 
23
from bzrlib.log import (show_log, 
 
24
                        get_view_revisions, 
 
25
                        LogFormatter, 
 
26
                        LongLogFormatter, 
 
27
                        ShortLogFormatter, 
28
28
                        LineLogFormatter)
29
29
from bzrlib.branch import Branch
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
 
30
from bzrlib.errors import InvalidRevisionNumber
 
31
 
 
32
 
 
33
class _LogEntry(object):
 
34
    # should probably move into bzrlib.log?
 
35
    pass
56
36
 
57
37
 
58
38
class LogCatcher(LogFormatter):
64
44
 
65
45
    We should also test the LogFormatter.
66
46
    """
67
 
 
68
 
    supports_delta = True
69
 
 
70
47
    def __init__(self):
71
48
        super(LogCatcher, self).__init__(to_file=None)
72
49
        self.logs = []
73
50
 
74
 
    def log_revision(self, revision):
75
 
        self.logs.append(revision)
76
 
 
77
 
 
78
 
class TestShowLog(TestCaseWithTransport):
 
51
    def show(self, revno, rev, delta):
 
52
        le = _LogEntry()
 
53
        le.revno = revno
 
54
        le.rev = rev
 
55
        le.delta = delta
 
56
        self.logs.append(le)
 
57
 
 
58
 
 
59
class SimpleLogTest(TestCaseWithTransport):
79
60
 
80
61
    def checkDelta(self, delta, **kw):
81
62
        """Check the filenames touched by a delta are as expected."""
82
63
        for n in 'added', 'removed', 'renamed', 'modified', 'unchanged':
83
64
            expected = kw.get(n, [])
 
65
 
 
66
            # tests are written with unix paths; fix them up for windows
 
67
            #if os.sep != '/':
 
68
            #    expected = [x.replace('/', os.sep) for x in expected]
 
69
 
84
70
            # strip out only the path components
85
71
            got = [x[0] for x in getattr(delta, n)]
86
72
            self.assertEquals(expected, got)
128
114
 
129
115
        self.build_tree(['hello'])
130
116
        wt.add('hello')
131
 
        wt.commit('add one file',
132
 
                  committer=u'\u013d\xf3r\xe9m \xcdp\u0161\xfam '
133
 
                            u'<test@example.com>')
 
117
        wt.commit('add one file')
134
118
 
135
 
        lf = self.make_utf8_encoded_stringio()
 
119
        lf = StringIO()
136
120
        # log using regular thing
137
121
        show_log(b, LongLogFormatter(lf))
138
122
        lf.seek(0)
153
137
        eq(logentry.rev.message, 'add one file')
154
138
        d = logentry.delta
155
139
        self.log('log 2 delta: %r' % d)
156
 
        self.checkDelta(d, added=['hello'])
 
140
        # self.checkDelta(d, added=['hello'])
157
141
        
158
142
        # commit a log message with control characters
159
143
        msg = "All 8-bit chars: " +  ''.join([unichr(x) for x in range(256)])
180
164
        self.log("escaped commit message: %r", committed_msg)
181
165
        self.assert_(msg == committed_msg)
182
166
 
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
 
 
294
167
    def test_trailing_newlines(self):
295
168
        wt = self.make_branch_and_tree('.')
296
 
        b = make_commits_with_trailing_newlines(wt)
297
 
        sio = self.make_utf8_encoded_stringio()
 
169
        b = wt.branch
 
170
        b.nick='test'
 
171
        open('a', 'wb').write('hello moto\n')
 
172
        wt.add('a')
 
173
        wt.commit('simple log message', rev_id='a1'
 
174
                , timestamp=1132586655.459960938, timezone=-6*3600
 
175
                , committer='Joe Foo <joe@foo.com>')
 
176
        open('b', 'wb').write('goodbye\n')
 
177
        wt.add('b')
 
178
        wt.commit('multiline\nlog\nmessage\n', rev_id='a2'
 
179
                , timestamp=1132586842.411175966, timezone=-6*3600
 
180
                , committer='Joe Foo <joe@foo.com>')
 
181
 
 
182
        open('c', 'wb').write('just another manic monday\n')
 
183
        wt.add('c')
 
184
        wt.commit('single line with trailing newline\n', rev_id='a3'
 
185
                , timestamp=1132587176.835228920, timezone=-6*3600
 
186
                , committer = 'Joe Foo <joe@foo.com>')
 
187
 
 
188
        sio = StringIO()
298
189
        lf = ShortLogFormatter(to_file=sio)
299
190
        show_log(b, lf)
300
 
        self.assertEqualDiff(sio.getvalue(), """\
 
191
        self.assertEquals(sio.getvalue(), """\
301
192
    3 Joe Foo\t2005-11-21
302
193
      single line with trailing newline
303
194
 
304
 
    2 Joe Bar\t2005-11-21
 
195
    2 Joe Foo\t2005-11-21
305
196
      multiline
306
197
      log
307
198
      message
311
202
 
312
203
""")
313
204
 
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
 
 
 
205
        sio = StringIO()
 
206
        lf = LongLogFormatter(to_file=sio)
 
207
        show_log(b, lf)
 
208
        self.assertEquals(sio.getvalue(), """\
 
209
------------------------------------------------------------
 
210
revno: 3
 
211
committer: Joe Foo <joe@foo.com>
 
212
branch nick: test
 
213
timestamp: Mon 2005-11-21 09:32:56 -0600
 
214
message:
 
215
  single line with trailing newline
 
216
------------------------------------------------------------
 
217
revno: 2
 
218
committer: Joe Foo <joe@foo.com>
 
219
branch nick: test
 
220
timestamp: Mon 2005-11-21 09:27:22 -0600
 
221
message:
 
222
  multiline
 
223
  log
 
224
  message
 
225
------------------------------------------------------------
 
226
revno: 1
 
227
committer: Joe Foo <joe@foo.com>
 
228
branch nick: test
 
229
timestamp: Mon 2005-11-21 09:24:15 -0600
 
230
message:
 
231
  simple log message
 
232
""")
 
233
        
377
234
    def test_verbose_log(self):
378
235
        """Verbose log includes changed files
379
236
        
407
264
  a
408
265
''')
409
266
 
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
 
 
685
267
    def test_line_log(self):
686
268
        """Line log should show revno
687
269
        
702
284
        logfile.flush()
703
285
        logfile.seek(0)
704
286
        log_contents = logfile.read()
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):
 
287
        self.assertEqualDiff(log_contents, '1: Line-Log-Formatte... 2005-11-23 add a\n')
751
288
 
752
289
    def make_tree_with_commits(self):
753
290
        """Create a tree with well-known revision ids"""
791
328
        full_rev_nos_for_reference = {
792
329
            '1': '1',
793
330
            '2': '2',
794
 
            '3a': '2.1.1', #first commit tree 3
795
 
            '3b': '2.2.1', # first commit tree 2
 
331
            '3a': '2.2.1', #first commit tree 3
 
332
            '3b': '2.1.1', # first commit tree 2
796
333
            '3c': '3', #merges 3b to main
797
 
            '4a': '2.2.2', # second commit tree 2
 
334
            '4a': '2.1.2', # second commit tree 2
798
335
            '4b': '4', # merges 4a to main
799
336
            }
800
337
        return mainline_revs, rev_nos, wt
802
339
    def test_get_view_revisions_forward(self):
803
340
        """Test the get_view_revisions method"""
804
341
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
805
 
        wt.lock_read()
806
 
        self.addCleanup(wt.unlock)
807
342
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
808
343
                                            'forward'))
809
344
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0)],
815
350
    def test_get_view_revisions_reverse(self):
816
351
        """Test the get_view_revisions with reverse"""
817
352
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
818
 
        wt.lock_read()
819
 
        self.addCleanup(wt.unlock)
820
353
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
821
354
                                            'reverse'))
822
355
        self.assertEqual([('3', '3', 0), ('2', '2', 0), ('1', '1', 0), ],
828
361
    def test_get_view_revisions_merge(self):
829
362
        """Test get_view_revisions when there are merges"""
830
363
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
831
 
        wt.lock_read()
832
 
        self.addCleanup(wt.unlock)
833
364
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
834
365
                                            'forward'))
835
366
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0),
844
375
    def test_get_view_revisions_merge_reverse(self):
845
376
        """Test get_view_revisions in reverse when there are merges"""
846
377
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
847
 
        wt.lock_read()
848
 
        self.addCleanup(wt.unlock)
849
378
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
850
379
                                            'reverse'))
851
380
        self.assertEqual([('4b', '4', 0), ('4a', '3.1.1', 1),
860
389
    def test_get_view_revisions_merge2(self):
861
390
        """Test get_view_revisions when there are merges"""
862
391
        mainline_revs, rev_nos, wt = self.make_tree_with_many_merges()
863
 
        wt.lock_read()
864
 
        self.addCleanup(wt.unlock)
865
392
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
866
393
                                            'forward'))
867
394
        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)]
 
395
            ('3a', '2.2.1', 1), ('3b', '2.1.1', 1), ('4b', '4', 0),
 
396
            ('4a', '2.1.2', 1)]
870
397
        self.assertEqual(expected, revisions)
871
398
        revisions = list(get_view_revisions(mainline_revs, rev_nos, wt.branch,
872
399
                                             'forward', include_merges=False))
873
400
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3c', '3', 0),
874
401
            ('4b', '4', 0)],
875
402
            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))