/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_log.py

add single revision tests

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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
import os
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
 
        # Use a clean registry for log
 
36
        # clean up the registry in log
58
37
        log.properties_handler_registry = registry.Registry()
59
38
 
60
 
        def restore():
61
 
            log.properties_handler_registry = self.properties_handler_registry
62
 
        self.addCleanup(restore)
63
 
 
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
 
39
    def _cleanup(self):
 
40
        super(TestCaseWithoutPropsHandler, self)._cleanup()
 
41
        # restore the custom properties handler registry
 
42
        log.properties_handler_registry = self.properties_handler_registry
 
43
 
119
44
 
120
45
class LogCatcher(log.LogFormatter):
121
 
    """Pull log messages into a list rather than displaying them.
122
 
 
123
 
    To simplify testing we save logged revisions here rather than actually
124
 
    formatting anything, so that we can precisely check the result without
125
 
    being dependent on the formatting.
 
46
    """Pull log messages into list rather than displaying them.
 
47
 
 
48
    For ease of testing we save log messages here rather than actually
 
49
    formatting them, so that we can precisely check the result without
 
50
    being too dependent on the exact formatting.
 
51
 
 
52
    We should also test the LogFormatter.
126
53
    """
127
54
 
128
 
    supports_merge_revisions = True
129
55
    supports_delta = True
130
 
    supports_diff = True
131
 
    preferred_levels = 0
132
56
 
133
 
    def __init__(self, *args, **kwargs):
134
 
        kwargs.update(dict(to_file=None))
135
 
        super(LogCatcher, self).__init__(*args, **kwargs)
136
 
        self.revisions = []
 
57
    def __init__(self):
 
58
        super(LogCatcher, self).__init__(to_file=None)
 
59
        self.logs = []
137
60
 
138
61
    def log_revision(self, revision):
139
 
        self.revisions.append(revision)
 
62
        self.logs.append(revision)
140
63
 
141
64
 
142
65
class TestShowLog(tests.TestCaseWithTransport):
183
106
        lf = LogCatcher()
184
107
        log.show_log(wt.branch, lf)
185
108
        # no entries yet
186
 
        self.assertEqual([], lf.revisions)
 
109
        self.assertEqual([], lf.logs)
187
110
 
188
111
    def test_empty_commit(self):
189
112
        wt = self.make_branch_and_tree('.')
191
114
        wt.commit('empty commit')
192
115
        lf = LogCatcher()
193
116
        log.show_log(wt.branch, lf, verbose=True)
194
 
        revs = lf.revisions
195
 
        self.assertEqual(1, len(revs))
196
 
        self.assertEqual('1', revs[0].revno)
197
 
        self.assertEqual('empty commit', revs[0].rev.message)
198
 
        self.checkDelta(revs[0].delta)
 
117
        self.assertEqual(1, len(lf.logs))
 
118
        self.assertEqual('1', lf.logs[0].revno)
 
119
        self.assertEqual('empty commit', lf.logs[0].rev.message)
 
120
        self.checkDelta(lf.logs[0].delta)
199
121
 
200
122
    def test_simple_commit(self):
201
123
        wt = self.make_branch_and_tree('.')
207
129
                            u'<test@example.com>')
208
130
        lf = LogCatcher()
209
131
        log.show_log(wt.branch, lf, verbose=True)
210
 
        self.assertEqual(2, len(lf.revisions))
 
132
        self.assertEqual(2, len(lf.logs))
211
133
        # first one is most recent
212
 
        log_entry = lf.revisions[0]
 
134
        log_entry = lf.logs[0]
213
135
        self.assertEqual('2', log_entry.revno)
214
136
        self.assertEqual('add one file', log_entry.rev.message)
215
137
        self.checkDelta(log_entry.delta, added=['hello'])
221
143
        wt.commit(msg)
222
144
        lf = LogCatcher()
223
145
        log.show_log(wt.branch, lf, verbose=True)
224
 
        committed_msg = lf.revisions[0].rev.message
225
 
        if wt.branch.repository._serializer.squashes_xml_invalid_characters:
226
 
            self.assertNotEqual(msg, committed_msg)
227
 
            self.assertTrue(len(committed_msg) > len(msg))
228
 
        else:
229
 
            self.assertEqual(msg, committed_msg)
 
146
        committed_msg = lf.logs[0].rev.message
 
147
        self.assertNotEqual(msg, committed_msg)
 
148
        self.assertTrue(len(committed_msg) > len(msg))
230
149
 
231
150
    def test_commit_message_without_control_chars(self):
232
151
        wt = self.make_branch_and_tree('.')
238
157
        wt.commit(msg)
239
158
        lf = LogCatcher()
240
159
        log.show_log(wt.branch, lf, verbose=True)
241
 
        committed_msg = lf.revisions[0].rev.message
 
160
        committed_msg = lf.logs[0].rev.message
242
161
        self.assertEqual(msg, committed_msg)
243
162
 
244
163
    def test_deltas_in_merge_revisions(self):
262
181
        lf.supports_merge_revisions = True
263
182
        log.show_log(b, lf, verbose=True)
264
183
 
265
 
        revs = lf.revisions
266
 
        self.assertEqual(3, len(revs))
 
184
        self.assertEqual(3, len(lf.logs))
267
185
 
268
 
        logentry = revs[0]
 
186
        logentry = lf.logs[0]
269
187
        self.assertEqual('2', logentry.revno)
270
188
        self.assertEqual('merge child branch', logentry.rev.message)
271
189
        self.checkDelta(logentry.delta, removed=['file1'], modified=['file2'])
272
190
 
273
 
        logentry = revs[1]
 
191
        logentry = lf.logs[1]
274
192
        self.assertEqual('1.1.1', logentry.revno)
275
193
        self.assertEqual('remove file1 and modify file2', logentry.rev.message)
276
194
        self.checkDelta(logentry.delta, removed=['file1'], modified=['file2'])
277
195
 
278
 
        logentry = revs[2]
 
196
        logentry = lf.logs[2]
279
197
        self.assertEqual('1', logentry.revno)
280
198
        self.assertEqual('add file1 and file2', logentry.rev.message)
281
199
        self.checkDelta(logentry.delta, added=['file1', 'file2'])
282
200
 
283
 
 
284
 
class TestShortLogFormatter(TestCaseForLogFormatter):
 
201
    def test_merges_nonsupporting_formatter(self):
 
202
        """Tests that show_log will raise if the formatter doesn't
 
203
        support merge revisions."""
 
204
        wt = self.make_branch_and_memory_tree('.')
 
205
        wt.lock_write()
 
206
        self.addCleanup(wt.unlock)
 
207
        wt.add('')
 
208
        wt.commit('rev-1', rev_id='rev-1',
 
209
                  timestamp=1132586655, timezone=36000,
 
210
                  committer='Joe Foo <joe@foo.com>')
 
211
        wt.commit('rev-merged', rev_id='rev-2a',
 
212
                  timestamp=1132586700, timezone=36000,
 
213
                  committer='Joe Foo <joe@foo.com>')
 
214
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
215
        wt.branch.set_last_revision_info(1, 'rev-1')
 
216
        wt.commit('rev-2', rev_id='rev-2b',
 
217
                  timestamp=1132586800, timezone=36000,
 
218
                  committer='Joe Foo <joe@foo.com>')
 
219
        logfile = self.make_utf8_encoded_stringio()
 
220
        formatter = log.ShortLogFormatter(to_file=logfile)
 
221
        wtb = wt.branch
 
222
        lf = LogCatcher()
 
223
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
 
224
        rev = revspec.in_history(wtb)
 
225
        self.assertRaises(errors.BzrCommandError, log.show_log, wtb, lf,
 
226
                          start_revision=rev, end_revision=rev)
 
227
 
 
228
 
 
229
def make_commits_with_trailing_newlines(wt):
 
230
    """Helper method for LogFormatter tests"""
 
231
    b = wt.branch
 
232
    b.nick='test'
 
233
    open('a', 'wb').write('hello moto\n')
 
234
    wt.add('a')
 
235
    wt.commit('simple log message', rev_id='a1',
 
236
              timestamp=1132586655.459960938, timezone=-6*3600,
 
237
              committer='Joe Foo <joe@foo.com>')
 
238
    open('b', 'wb').write('goodbye\n')
 
239
    wt.add('b')
 
240
    wt.commit('multiline\nlog\nmessage\n', rev_id='a2',
 
241
              timestamp=1132586842.411175966, timezone=-6*3600,
 
242
              committer='Joe Foo <joe@foo.com>',
 
243
              author='Joe Bar <joe@bar.com>')
 
244
 
 
245
    open('c', 'wb').write('just another manic monday\n')
 
246
    wt.add('c')
 
247
    wt.commit('single line with trailing newline\n', rev_id='a3',
 
248
              timestamp=1132587176.835228920, timezone=-6*3600,
 
249
              committer = 'Joe Foo <joe@foo.com>')
 
250
    return b
 
251
 
 
252
 
 
253
def normalize_log(log):
 
254
    """Replaces the variable lines of logs with fixed lines"""
 
255
    author = 'author: Dolor Sit <test@example.com>'
 
256
    committer = 'committer: Lorem Ipsum <test@example.com>'
 
257
    lines = log.splitlines(True)
 
258
    for idx,line in enumerate(lines):
 
259
        stripped_line = line.lstrip()
 
260
        indent = ' ' * (len(line) - len(stripped_line))
 
261
        if stripped_line.startswith('author:'):
 
262
            lines[idx] = indent + author + '\n'
 
263
        elif stripped_line.startswith('committer:'):
 
264
            lines[idx] = indent + committer + '\n'
 
265
        elif stripped_line.startswith('timestamp:'):
 
266
            lines[idx] = indent + 'timestamp: Just now\n'
 
267
    return ''.join(lines)
 
268
 
 
269
 
 
270
class TestShortLogFormatter(tests.TestCaseWithTransport):
285
271
 
286
272
    def test_trailing_newlines(self):
287
273
        wt = self.make_branch_and_tree('.')
288
 
        b = self.make_commits_with_trailing_newlines(wt)
289
 
        self.assertFormatterResult("""\
290
 
    3 Joe Foo\t2005-11-22
 
274
        b = make_commits_with_trailing_newlines(wt)
 
275
        sio = self.make_utf8_encoded_stringio()
 
276
        lf = log.ShortLogFormatter(to_file=sio)
 
277
        log.show_log(b, lf)
 
278
        self.assertEqualDiff("""\
 
279
    3 Joe Foo\t2005-11-21
291
280
      single line with trailing newline
292
281
 
293
 
    2 Joe Foo\t2005-11-22
 
282
    2 Joe Bar\t2005-11-21
294
283
      multiline
295
284
      log
296
285
      message
297
286
 
298
 
    1 Joe Foo\t2005-11-22
 
287
    1 Joe Foo\t2005-11-21
299
288
      simple log message
300
289
 
301
290
""",
302
 
            b, log.ShortLogFormatter)
 
291
                             sio.getvalue())
 
292
 
 
293
    def _prepare_tree_with_merges(self, with_tags=False):
 
294
        wt = self.make_branch_and_memory_tree('.')
 
295
        wt.lock_write()
 
296
        self.addCleanup(wt.unlock)
 
297
        wt.add('')
 
298
        wt.commit('rev-1', rev_id='rev-1',
 
299
                  timestamp=1132586655, timezone=36000,
 
300
                  committer='Joe Foo <joe@foo.com>')
 
301
        wt.commit('rev-merged', rev_id='rev-2a',
 
302
                  timestamp=1132586700, timezone=36000,
 
303
                  committer='Joe Foo <joe@foo.com>')
 
304
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
305
        wt.branch.set_last_revision_info(1, 'rev-1')
 
306
        wt.commit('rev-2', rev_id='rev-2b',
 
307
                  timestamp=1132586800, timezone=36000,
 
308
                  committer='Joe Foo <joe@foo.com>')
 
309
        if with_tags:
 
310
            branch = wt.branch
 
311
            branch.tags.set_tag('v0.2', 'rev-2b')
 
312
            wt.commit('rev-3', rev_id='rev-3',
 
313
                      timestamp=1132586900, timezone=36000,
 
314
                      committer='Jane Foo <jane@foo.com>')
 
315
            branch.tags.set_tag('v1.0rc1', 'rev-3')
 
316
            branch.tags.set_tag('v1.0', 'rev-3')
 
317
        return wt
303
318
 
304
319
    def test_short_log_with_merges(self):
305
320
        wt = self._prepare_tree_with_merges()
306
 
        self.assertFormatterResult("""\
307
 
    2 Joe Foo\t2005-11-22 [merge]
308
 
      rev-2
309
 
 
310
 
    1 Joe Foo\t2005-11-22
311
 
      rev-1
312
 
 
313
 
""",
314
 
            wt.branch, log.ShortLogFormatter)
315
 
 
316
 
    def test_short_log_with_merges_and_advice(self):
317
 
        wt = self._prepare_tree_with_merges()
318
 
        self.assertFormatterResult("""\
319
 
    2 Joe Foo\t2005-11-22 [merge]
320
 
      rev-2
321
 
 
322
 
    1 Joe Foo\t2005-11-22
323
 
      rev-1
324
 
 
325
 
Use --include-merges or -n0 to see merged revisions.
326
 
""",
327
 
            wt.branch, log.ShortLogFormatter,
328
 
            formatter_kwargs=dict(show_advice=True))
 
321
        logfile = self.make_utf8_encoded_stringio()
 
322
        formatter = log.ShortLogFormatter(to_file=logfile)
 
323
        log.show_log(wt.branch, formatter)
 
324
        self.assertEqualDiff("""\
 
325
    2 Joe Foo\t2005-11-22 [merge]
 
326
      rev-2
 
327
 
 
328
    1 Joe Foo\t2005-11-22
 
329
      rev-1
 
330
 
 
331
""",
 
332
                             logfile.getvalue())
329
333
 
330
334
    def test_short_log_with_merges_and_range(self):
331
 
        wt = self._prepare_tree_with_merges()
332
 
        self.wt_commit(wt, 'rev-3a', rev_id='rev-3a')
 
335
        wt = self.make_branch_and_memory_tree('.')
 
336
        wt.lock_write()
 
337
        self.addCleanup(wt.unlock)
 
338
        wt.add('')
 
339
        wt.commit('rev-1', rev_id='rev-1',
 
340
                  timestamp=1132586655, timezone=36000,
 
341
                  committer='Joe Foo <joe@foo.com>')
 
342
        wt.commit('rev-merged', rev_id='rev-2a',
 
343
                  timestamp=1132586700, timezone=36000,
 
344
                  committer='Joe Foo <joe@foo.com>')
 
345
        wt.branch.set_last_revision_info(1, 'rev-1')
 
346
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
347
        wt.commit('rev-2b', rev_id='rev-2b',
 
348
                  timestamp=1132586800, timezone=36000,
 
349
                  committer='Joe Foo <joe@foo.com>')
 
350
        wt.commit('rev-3a', rev_id='rev-3a',
 
351
                  timestamp=1132586800, timezone=36000,
 
352
                  committer='Joe Foo <joe@foo.com>')
333
353
        wt.branch.set_last_revision_info(2, 'rev-2b')
334
354
        wt.set_parent_ids(['rev-2b', 'rev-3a'])
335
 
        self.wt_commit(wt, 'rev-3b', rev_id='rev-3b')
336
 
        self.assertFormatterResult("""\
 
355
        wt.commit('rev-3b', rev_id='rev-3b',
 
356
                  timestamp=1132586800, timezone=36000,
 
357
                  committer='Joe Foo <joe@foo.com>')
 
358
        logfile = self.make_utf8_encoded_stringio()
 
359
        formatter = log.ShortLogFormatter(to_file=logfile)
 
360
        log.show_log(wt.branch, formatter,
 
361
            start_revision=2, end_revision=3)
 
362
        self.assertEqualDiff("""\
337
363
    3 Joe Foo\t2005-11-22 [merge]
338
364
      rev-3b
339
365
 
340
366
    2 Joe Foo\t2005-11-22 [merge]
341
 
      rev-2
 
367
      rev-2b
342
368
 
343
369
""",
344
 
            wt.branch, log.ShortLogFormatter,
345
 
            show_log_kwargs=dict(start_revision=2, end_revision=3))
 
370
                             logfile.getvalue())
346
371
 
347
372
    def test_short_log_with_tags(self):
348
373
        wt = self._prepare_tree_with_merges(with_tags=True)
349
 
        self.assertFormatterResult("""\
350
 
    3 Joe Foo\t2005-11-22 {v1.0, v1.0rc1}
 
374
        logfile = self.make_utf8_encoded_stringio()
 
375
        formatter = log.ShortLogFormatter(to_file=logfile)
 
376
        log.show_log(wt.branch, formatter)
 
377
        self.assertEqualDiff("""\
 
378
    3 Jane Foo\t2005-11-22 {v1.0, v1.0rc1}
351
379
      rev-3
352
380
 
353
381
    2 Joe Foo\t2005-11-22 {v0.2} [merge]
357
385
      rev-1
358
386
 
359
387
""",
360
 
            wt.branch, log.ShortLogFormatter)
 
388
                             logfile.getvalue())
361
389
 
362
390
    def test_short_log_single_merge_revision(self):
363
 
        wt = self._prepare_tree_with_merges()
364
 
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
365
 
        rev = revspec.in_history(wt.branch)
366
 
        self.assertFormatterResult("""\
367
 
      1.1.1 Joe Foo\t2005-11-22
368
 
            rev-merged
369
 
 
370
 
""",
371
 
            wt.branch, log.ShortLogFormatter,
372
 
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
373
 
 
374
 
 
375
 
class TestShortLogFormatterWithMergeRevisions(TestCaseForLogFormatter):
376
 
 
377
 
    def test_short_merge_revs_log_with_merges(self):
378
 
        wt = self._prepare_tree_with_merges()
379
 
        # Note that the 1.1.1 indenting is in fact correct given that
380
 
        # the revision numbers are right justified within 5 characters
381
 
        # for mainline revnos and 9 characters for dotted revnos.
382
 
        self.assertFormatterResult("""\
383
 
    2 Joe Foo\t2005-11-22 [merge]
384
 
      rev-2
385
 
 
386
 
          1.1.1 Joe Foo\t2005-11-22
387
 
                rev-merged
388
 
 
389
 
    1 Joe Foo\t2005-11-22
390
 
      rev-1
391
 
 
392
 
""",
393
 
            wt.branch, log.ShortLogFormatter,
394
 
            formatter_kwargs=dict(levels=0))
395
 
 
396
 
    def test_short_merge_revs_log_single_merge_revision(self):
397
 
        wt = self._prepare_tree_with_merges()
398
 
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
399
 
        rev = revspec.in_history(wt.branch)
400
 
        self.assertFormatterResult("""\
401
 
      1.1.1 Joe Foo\t2005-11-22
402
 
            rev-merged
403
 
 
404
 
""",
405
 
            wt.branch, log.ShortLogFormatter,
406
 
            formatter_kwargs=dict(levels=0),
407
 
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
408
 
 
409
 
 
410
 
class TestLongLogFormatter(TestCaseForLogFormatter):
 
391
        wt = self.make_branch_and_memory_tree('.')
 
392
        wt.lock_write()
 
393
        self.addCleanup(wt.unlock)
 
394
        wt.add('')
 
395
        wt.commit('rev-1', rev_id='rev-1',
 
396
                  timestamp=1132586655, timezone=36000,
 
397
                  committer='Joe Foo <joe@foo.com>')
 
398
        wt.commit('rev-merged', rev_id='rev-2a',
 
399
                  timestamp=1132586700, timezone=36000,
 
400
                  committer='Joe Foo <joe@foo.com>')
 
401
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
402
        wt.branch.set_last_revision_info(1, 'rev-1')
 
403
        wt.commit('rev-2', rev_id='rev-2b',
 
404
                  timestamp=1132586800, timezone=36000,
 
405
                  committer='Joe Foo <joe@foo.com>')
 
406
        logfile = self.make_utf8_encoded_stringio()
 
407
        formatter = log.ShortLogFormatter(to_file=logfile)
 
408
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
 
409
        wtb = wt.branch
 
410
        rev = revspec.in_history(wtb)
 
411
        log.show_log(wtb, formatter, start_revision=rev, end_revision=rev)
 
412
        self.assertEqualDiff("""\
 
413
1.1.1 Joe Foo\t2005-11-22
 
414
      rev-merged
 
415
 
 
416
""",
 
417
                             logfile.getvalue())
 
418
 
 
419
 
 
420
class TestLongLogFormatter(TestCaseWithoutPropsHandler):
411
421
 
412
422
    def test_verbose_log(self):
413
423
        """Verbose log includes changed files
414
 
 
 
424
        
415
425
        bug #4676
416
426
        """
417
 
        wt = self.make_standard_commit('test_verbose_log', authors=[])
418
 
        self.assertFormatterResult('''\
 
427
        wt = self.make_branch_and_tree('.')
 
428
        b = wt.branch
 
429
        self.build_tree(['a'])
 
430
        wt.add('a')
 
431
        # XXX: why does a longer nick show up?
 
432
        b.nick = 'test_verbose_log'
 
433
        wt.commit(message='add a',
 
434
                  timestamp=1132711707,
 
435
                  timezone=36000,
 
436
                  committer='Lorem Ipsum <test@example.com>')
 
437
        logfile = file('out.tmp', 'w+')
 
438
        formatter = log.LongLogFormatter(to_file=logfile)
 
439
        log.show_log(b, formatter, verbose=True)
 
440
        logfile.flush()
 
441
        logfile.seek(0)
 
442
        log_contents = logfile.read()
 
443
        self.assertEqualDiff('''\
419
444
------------------------------------------------------------
420
445
revno: 1
421
446
committer: Lorem Ipsum <test@example.com>
422
447
branch nick: test_verbose_log
423
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
448
timestamp: Wed 2005-11-23 12:08:27 +1000
424
449
message:
425
450
  add a
426
451
added:
427
452
  a
428
453
''',
429
 
            wt.branch, log.LongLogFormatter,
430
 
            show_log_kwargs=dict(verbose=True))
 
454
                             log_contents)
431
455
 
432
456
    def test_merges_are_indented_by_level(self):
433
457
        wt = self.make_branch_and_tree('parent')
434
 
        self.wt_commit(wt, 'first post')
435
 
        child_wt = wt.bzrdir.sprout('child').open_workingtree()
436
 
        self.wt_commit(child_wt, 'branch 1')
437
 
        smallerchild_wt = wt.bzrdir.sprout('smallerchild').open_workingtree()
438
 
        self.wt_commit(smallerchild_wt, 'branch 2')
439
 
        child_wt.merge_from_branch(smallerchild_wt.branch)
440
 
        self.wt_commit(child_wt, 'merge branch 2')
441
 
        wt.merge_from_branch(child_wt.branch)
442
 
        self.wt_commit(wt, 'merge branch 1')
443
 
        self.assertFormatterResult("""\
 
458
        wt.commit('first post')
 
459
        self.run_bzr('branch parent child')
 
460
        self.run_bzr(['commit', '-m', 'branch 1', '--unchanged', 'child'])
 
461
        self.run_bzr('branch child smallerchild')
 
462
        self.run_bzr(['commit', '-m', 'branch 2', '--unchanged',
 
463
            'smallerchild'])
 
464
        os.chdir('child')
 
465
        self.run_bzr('merge ../smallerchild')
 
466
        self.run_bzr(['commit', '-m', 'merge branch 2'])
 
467
        os.chdir('../parent')
 
468
        self.run_bzr('merge ../child')
 
469
        wt.commit('merge branch 1')
 
470
        b = wt.branch
 
471
        sio = self.make_utf8_encoded_stringio()
 
472
        lf = log.LongLogFormatter(to_file=sio)
 
473
        log.show_log(b, lf, verbose=True)
 
474
        the_log = normalize_log(sio.getvalue())
 
475
        self.assertEqualDiff("""\
444
476
------------------------------------------------------------
445
 
revno: 2 [merge]
446
 
committer: Joe Foo <joe@foo.com>
 
477
revno: 2
 
478
committer: Lorem Ipsum <test@example.com>
447
479
branch nick: parent
448
 
timestamp: Tue 2005-11-22 00:00:04 +0000
 
480
timestamp: Just now
449
481
message:
450
482
  merge branch 1
451
483
    ------------------------------------------------------------
452
 
    revno: 1.1.2 [merge]
453
 
    committer: Joe Foo <joe@foo.com>
 
484
    revno: 1.1.2
 
485
    committer: Lorem Ipsum <test@example.com>
454
486
    branch nick: child
455
 
    timestamp: Tue 2005-11-22 00:00:03 +0000
 
487
    timestamp: Just now
456
488
    message:
457
489
      merge branch 2
458
490
        ------------------------------------------------------------
459
491
        revno: 1.2.1
460
 
        committer: Joe Foo <joe@foo.com>
 
492
        committer: Lorem Ipsum <test@example.com>
461
493
        branch nick: smallerchild
462
 
        timestamp: Tue 2005-11-22 00:00:02 +0000
 
494
        timestamp: Just now
463
495
        message:
464
496
          branch 2
465
497
    ------------------------------------------------------------
466
498
    revno: 1.1.1
467
 
    committer: Joe Foo <joe@foo.com>
 
499
    committer: Lorem Ipsum <test@example.com>
468
500
    branch nick: child
469
 
    timestamp: Tue 2005-11-22 00:00:01 +0000
 
501
    timestamp: Just now
470
502
    message:
471
503
      branch 1
472
504
------------------------------------------------------------
473
505
revno: 1
474
 
committer: Joe Foo <joe@foo.com>
 
506
committer: Lorem Ipsum <test@example.com>
475
507
branch nick: parent
476
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
508
timestamp: Just now
477
509
message:
478
510
  first post
479
511
""",
480
 
            wt.branch, log.LongLogFormatter,
481
 
            formatter_kwargs=dict(levels=0),
482
 
            show_log_kwargs=dict(verbose=True))
 
512
                             the_log)
483
513
 
484
514
    def test_verbose_merge_revisions_contain_deltas(self):
485
515
        wt = self.make_branch_and_tree('parent')
486
516
        self.build_tree(['parent/f1', 'parent/f2'])
487
517
        wt.add(['f1','f2'])
488
 
        self.wt_commit(wt, 'first post')
489
 
        child_wt = wt.bzrdir.sprout('child').open_workingtree()
 
518
        wt.commit('first post')
 
519
        self.run_bzr('branch parent child')
490
520
        os.unlink('child/f1')
491
 
        self.build_tree_contents([('child/f2', 'hello\n')])
492
 
        self.wt_commit(child_wt, 'removed f1 and modified f2')
493
 
        wt.merge_from_branch(child_wt.branch)
494
 
        self.wt_commit(wt, 'merge branch 1')
495
 
        self.assertFormatterResult("""\
 
521
        file('child/f2', 'wb').write('hello\n')
 
522
        self.run_bzr(['commit', '-m', 'removed f1 and modified f2',
 
523
            'child'])
 
524
        os.chdir('parent')
 
525
        self.run_bzr('merge ../child')
 
526
        wt.commit('merge branch 1')
 
527
        b = wt.branch
 
528
        sio = self.make_utf8_encoded_stringio()
 
529
        lf = log.LongLogFormatter(to_file=sio)
 
530
        log.show_log(b, lf, verbose=True)
 
531
        the_log = normalize_log(sio.getvalue())
 
532
        self.assertEqualDiff("""\
496
533
------------------------------------------------------------
497
 
revno: 2 [merge]
498
 
committer: Joe Foo <joe@foo.com>
 
534
revno: 2
 
535
committer: Lorem Ipsum <test@example.com>
499
536
branch nick: parent
500
 
timestamp: Tue 2005-11-22 00:00:02 +0000
 
537
timestamp: Just now
501
538
message:
502
539
  merge branch 1
503
540
removed:
506
543
  f2
507
544
    ------------------------------------------------------------
508
545
    revno: 1.1.1
509
 
    committer: Joe Foo <joe@foo.com>
 
546
    committer: Lorem Ipsum <test@example.com>
510
547
    branch nick: child
511
 
    timestamp: Tue 2005-11-22 00:00:01 +0000
 
548
    timestamp: Just now
512
549
    message:
513
550
      removed f1 and modified f2
514
551
    removed:
517
554
      f2
518
555
------------------------------------------------------------
519
556
revno: 1
520
 
committer: Joe Foo <joe@foo.com>
 
557
committer: Lorem Ipsum <test@example.com>
521
558
branch nick: parent
522
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
559
timestamp: Just now
523
560
message:
524
561
  first post
525
562
added:
526
563
  f1
527
564
  f2
528
565
""",
529
 
            wt.branch, log.LongLogFormatter,
530
 
            formatter_kwargs=dict(levels=0),
531
 
            show_log_kwargs=dict(verbose=True))
 
566
                             the_log)
532
567
 
533
568
    def test_trailing_newlines(self):
534
569
        wt = self.make_branch_and_tree('.')
535
 
        b = self.make_commits_with_trailing_newlines(wt)
536
 
        self.assertFormatterResult("""\
 
570
        b = make_commits_with_trailing_newlines(wt)
 
571
        sio = self.make_utf8_encoded_stringio()
 
572
        lf = log.LongLogFormatter(to_file=sio)
 
573
        log.show_log(b, lf)
 
574
        self.assertEqualDiff("""\
537
575
------------------------------------------------------------
538
576
revno: 3
539
577
committer: Joe Foo <joe@foo.com>
540
578
branch nick: test
541
 
timestamp: Tue 2005-11-22 00:00:02 +0000
 
579
timestamp: Mon 2005-11-21 09:32:56 -0600
542
580
message:
543
581
  single line with trailing newline
544
582
------------------------------------------------------------
545
583
revno: 2
 
584
author: Joe Bar <joe@bar.com>
546
585
committer: Joe Foo <joe@foo.com>
547
586
branch nick: test
548
 
timestamp: Tue 2005-11-22 00:00:01 +0000
 
587
timestamp: Mon 2005-11-21 09:27:22 -0600
549
588
message:
550
589
  multiline
551
590
  log
554
593
revno: 1
555
594
committer: Joe Foo <joe@foo.com>
556
595
branch nick: test
557
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
596
timestamp: Mon 2005-11-21 09:24:15 -0600
558
597
message:
559
598
  simple log message
560
599
""",
561
 
        b, log.LongLogFormatter)
 
600
                             sio.getvalue())
562
601
 
563
602
    def test_author_in_log(self):
564
603
        """Log includes the author name if it's set in
565
604
        the revision properties
566
605
        """
567
 
        wt = self.make_standard_commit('test_author_log',
568
 
            authors=['John Doe <jdoe@example.com>',
569
 
                     'Jane Rey <jrey@example.com>'])
570
 
        self.assertFormatterResult("""\
 
606
        wt = self.make_branch_and_tree('.')
 
607
        b = wt.branch
 
608
        self.build_tree(['a'])
 
609
        wt.add('a')
 
610
        b.nick = 'test_author_log'
 
611
        wt.commit(message='add a',
 
612
                  timestamp=1132711707,
 
613
                  timezone=36000,
 
614
                  committer='Lorem Ipsum <test@example.com>',
 
615
                  author='John Doe <jdoe@example.com>')
 
616
        sio = StringIO()
 
617
        formatter = log.LongLogFormatter(to_file=sio)
 
618
        log.show_log(b, formatter)
 
619
        self.assertEqualDiff('''\
571
620
------------------------------------------------------------
572
621
revno: 1
573
 
author: John Doe <jdoe@example.com>, Jane Rey <jrey@example.com>
 
622
author: John Doe <jdoe@example.com>
574
623
committer: Lorem Ipsum <test@example.com>
575
624
branch nick: test_author_log
576
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
625
timestamp: Wed 2005-11-23 12:08:27 +1000
577
626
message:
578
627
  add a
579
 
""",
580
 
        wt.branch, log.LongLogFormatter)
 
628
''',
 
629
                             sio.getvalue())
581
630
 
582
631
    def test_properties_in_log(self):
583
 
        """Log includes the custom properties returned by the registered
 
632
        """Log includes the custom properties returned by the registered 
584
633
        handlers.
585
634
        """
586
 
        wt = self.make_standard_commit('test_properties_in_log')
587
 
        def trivial_custom_prop_handler(revision):
588
 
            return {'test_prop':'test_value'}
 
635
        wt = self.make_branch_and_tree('.')
 
636
        b = wt.branch
 
637
        self.build_tree(['a'])
 
638
        wt.add('a')
 
639
        b.nick = 'test_properties_in_log'
 
640
        wt.commit(message='add a',
 
641
                  timestamp=1132711707,
 
642
                  timezone=36000,
 
643
                  committer='Lorem Ipsum <test@example.com>',
 
644
                  author='John Doe <jdoe@example.com>')
 
645
        sio = StringIO()
 
646
        formatter = log.LongLogFormatter(to_file=sio)
 
647
        try:
 
648
            def trivial_custom_prop_handler(revision):
 
649
                return {'test_prop':'test_value'}
589
650
 
590
 
        # Cleaned up in setUp()
591
 
        log.properties_handler_registry.register(
592
 
            'trivial_custom_prop_handler',
593
 
            trivial_custom_prop_handler)
594
 
        self.assertFormatterResult("""\
 
651
            log.properties_handler_registry.register(
 
652
                'trivial_custom_prop_handler',
 
653
                trivial_custom_prop_handler)
 
654
            log.show_log(b, formatter)
 
655
        finally:
 
656
            log.properties_handler_registry.remove(
 
657
                'trivial_custom_prop_handler')
 
658
            self.assertEqualDiff('''\
595
659
------------------------------------------------------------
596
660
revno: 1
597
661
test_prop: test_value
598
662
author: John Doe <jdoe@example.com>
599
663
committer: Lorem Ipsum <test@example.com>
600
664
branch nick: test_properties_in_log
601
 
timestamp: Tue 2005-11-22 00:00:00 +0000
 
665
timestamp: Wed 2005-11-23 12:08:27 +1000
602
666
message:
603
667
  add a
604
 
""",
605
 
            wt.branch, log.LongLogFormatter)
606
 
 
607
 
    def test_properties_in_short_log(self):
608
 
        """Log includes the custom properties returned by the registered
609
 
        handlers.
610
 
        """
611
 
        wt = self.make_standard_commit('test_properties_in_short_log')
612
 
        def trivial_custom_prop_handler(revision):
613
 
            return {'test_prop':'test_value'}
614
 
 
615
 
        log.properties_handler_registry.register(
616
 
            'trivial_custom_prop_handler',
617
 
            trivial_custom_prop_handler)
618
 
        self.assertFormatterResult("""\
619
 
    1 John Doe\t2005-11-22
620
 
      test_prop: test_value
621
 
      add a
622
 
 
623
 
""",
624
 
            wt.branch, log.ShortLogFormatter)
 
668
''',
 
669
                                 sio.getvalue())
625
670
 
626
671
    def test_error_in_properties_handler(self):
627
 
        """Log includes the custom properties returned by the registered
 
672
        """Log includes the custom properties returned by the registered 
628
673
        handlers.
629
674
        """
630
 
        wt = self.make_standard_commit('error_in_properties_handler',
631
 
            revprops={'first_prop':'first_value'})
632
 
        sio = self.make_utf8_encoded_stringio()
 
675
        wt = self.make_branch_and_tree('.')
 
676
        b = wt.branch
 
677
        self.build_tree(['a'])
 
678
        wt.add('a')
 
679
        b.nick = 'test_author_log'
 
680
        wt.commit(message='add a',
 
681
                  timestamp=1132711707,
 
682
                  timezone=36000,
 
683
                  committer='Lorem Ipsum <test@example.com>',
 
684
                  author='John Doe <jdoe@example.com>',
 
685
                  revprops={'first_prop':'first_value'})
 
686
        sio = StringIO()
633
687
        formatter = log.LongLogFormatter(to_file=sio)
634
 
        def trivial_custom_prop_handler(revision):
635
 
            raise StandardError("a test error")
 
688
        try:
 
689
            def trivial_custom_prop_handler(revision):
 
690
                raise StandardError("a test error")
636
691
 
637
 
        log.properties_handler_registry.register(
638
 
            'trivial_custom_prop_handler',
639
 
            trivial_custom_prop_handler)
640
 
        self.assertRaises(StandardError, log.show_log, wt.branch, formatter,)
 
692
            log.properties_handler_registry.register(
 
693
                'trivial_custom_prop_handler',
 
694
                trivial_custom_prop_handler)
 
695
            self.assertRaises(StandardError, log.show_log, b, formatter,)
 
696
        finally:
 
697
            log.properties_handler_registry.remove(
 
698
                'trivial_custom_prop_handler')
641
699
 
642
700
    def test_properties_handler_bad_argument(self):
643
 
        wt = self.make_standard_commit('bad_argument',
644
 
              revprops={'a_prop':'test_value'})
645
 
        sio = self.make_utf8_encoded_stringio()
 
701
        wt = self.make_branch_and_tree('.')
 
702
        b = wt.branch
 
703
        self.build_tree(['a'])
 
704
        wt.add('a')
 
705
        b.nick = 'test_author_log'
 
706
        wt.commit(message='add a',
 
707
                  timestamp=1132711707,
 
708
                  timezone=36000,
 
709
                  committer='Lorem Ipsum <test@example.com>',
 
710
                  author='John Doe <jdoe@example.com>',
 
711
                  revprops={'a_prop':'test_value'})
 
712
        sio = StringIO()
646
713
        formatter = log.LongLogFormatter(to_file=sio)
647
 
        def bad_argument_prop_handler(revision):
648
 
            return {'custom_prop_name':revision.properties['a_prop']}
649
 
 
650
 
        log.properties_handler_registry.register(
651
 
            'bad_argument_prop_handler',
652
 
            bad_argument_prop_handler)
653
 
 
654
 
        self.assertRaises(AttributeError, formatter.show_properties,
655
 
                          'a revision', '')
656
 
 
657
 
        revision = wt.branch.repository.get_revision(wt.branch.last_revision())
658
 
        formatter.show_properties(revision, '')
659
 
        self.assertEqualDiff('''custom_prop_name: test_value\n''',
660
 
                             sio.getvalue())
661
 
 
662
 
 
663
 
class TestLongLogFormatterWithoutMergeRevisions(TestCaseForLogFormatter):
664
 
 
665
 
    def test_long_verbose_log(self):
666
 
        """Verbose log includes changed files
667
 
 
668
 
        bug #4676
669
 
        """
670
 
        wt = self.make_standard_commit('test_long_verbose_log', authors=[])
671
 
        self.assertFormatterResult("""\
672
 
------------------------------------------------------------
673
 
revno: 1
674
 
committer: Lorem Ipsum <test@example.com>
675
 
branch nick: test_long_verbose_log
676
 
timestamp: Tue 2005-11-22 00:00:00 +0000
677
 
message:
678
 
  add a
679
 
added:
680
 
  a
681
 
""",
682
 
            wt.branch, log.LongLogFormatter,
683
 
            formatter_kwargs=dict(levels=1),
684
 
            show_log_kwargs=dict(verbose=True))
685
 
 
686
 
    def test_long_verbose_contain_deltas(self):
687
 
        wt = self.make_branch_and_tree('parent')
688
 
        self.build_tree(['parent/f1', 'parent/f2'])
689
 
        wt.add(['f1','f2'])
690
 
        self.wt_commit(wt, 'first post')
691
 
        child_wt = wt.bzrdir.sprout('child').open_workingtree()
692
 
        os.unlink('child/f1')
693
 
        self.build_tree_contents([('child/f2', 'hello\n')])
694
 
        self.wt_commit(child_wt, 'removed f1 and modified f2')
695
 
        wt.merge_from_branch(child_wt.branch)
696
 
        self.wt_commit(wt, 'merge branch 1')
697
 
        self.assertFormatterResult("""\
698
 
------------------------------------------------------------
699
 
revno: 2 [merge]
700
 
committer: Joe Foo <joe@foo.com>
701
 
branch nick: parent
702
 
timestamp: Tue 2005-11-22 00:00:02 +0000
703
 
message:
704
 
  merge branch 1
705
 
removed:
706
 
  f1
707
 
modified:
708
 
  f2
709
 
------------------------------------------------------------
710
 
revno: 1
711
 
committer: Joe Foo <joe@foo.com>
712
 
branch nick: parent
713
 
timestamp: Tue 2005-11-22 00:00:00 +0000
714
 
message:
715
 
  first post
716
 
added:
717
 
  f1
718
 
  f2
719
 
""",
720
 
            wt.branch, log.LongLogFormatter,
721
 
            formatter_kwargs=dict(levels=1),
722
 
            show_log_kwargs=dict(verbose=True))
723
 
 
724
 
    def test_long_trailing_newlines(self):
725
 
        wt = self.make_branch_and_tree('.')
726
 
        b = self.make_commits_with_trailing_newlines(wt)
727
 
        self.assertFormatterResult("""\
728
 
------------------------------------------------------------
729
 
revno: 3
730
 
committer: Joe Foo <joe@foo.com>
731
 
branch nick: test
732
 
timestamp: Tue 2005-11-22 00:00:02 +0000
733
 
message:
734
 
  single line with trailing newline
735
 
------------------------------------------------------------
736
 
revno: 2
737
 
committer: Joe Foo <joe@foo.com>
738
 
branch nick: test
739
 
timestamp: Tue 2005-11-22 00:00:01 +0000
740
 
message:
741
 
  multiline
742
 
  log
743
 
  message
744
 
------------------------------------------------------------
745
 
revno: 1
746
 
committer: Joe Foo <joe@foo.com>
747
 
branch nick: test
748
 
timestamp: Tue 2005-11-22 00:00:00 +0000
749
 
message:
750
 
  simple log message
751
 
""",
752
 
        b, log.LongLogFormatter,
753
 
        formatter_kwargs=dict(levels=1))
754
 
 
755
 
    def test_long_author_in_log(self):
756
 
        """Log includes the author name if it's set in
757
 
        the revision properties
758
 
        """
759
 
        wt = self.make_standard_commit('test_author_log')
760
 
        self.assertFormatterResult("""\
761
 
------------------------------------------------------------
762
 
revno: 1
763
 
author: John Doe <jdoe@example.com>
764
 
committer: Lorem Ipsum <test@example.com>
765
 
branch nick: test_author_log
766
 
timestamp: Tue 2005-11-22 00:00:00 +0000
767
 
message:
768
 
  add a
769
 
""",
770
 
            wt.branch, log.LongLogFormatter,
771
 
            formatter_kwargs=dict(levels=1))
772
 
 
773
 
    def test_long_properties_in_log(self):
774
 
        """Log includes the custom properties returned by the registered
775
 
        handlers.
776
 
        """
777
 
        wt = self.make_standard_commit('test_properties_in_log')
778
 
        def trivial_custom_prop_handler(revision):
779
 
            return {'test_prop':'test_value'}
780
 
 
781
 
        log.properties_handler_registry.register(
782
 
            'trivial_custom_prop_handler',
783
 
            trivial_custom_prop_handler)
784
 
        self.assertFormatterResult("""\
785
 
------------------------------------------------------------
786
 
revno: 1
787
 
test_prop: test_value
788
 
author: John Doe <jdoe@example.com>
789
 
committer: Lorem Ipsum <test@example.com>
790
 
branch nick: test_properties_in_log
791
 
timestamp: Tue 2005-11-22 00:00:00 +0000
792
 
message:
793
 
  add a
794
 
""",
795
 
            wt.branch, log.LongLogFormatter,
796
 
            formatter_kwargs=dict(levels=1))
797
 
 
798
 
 
799
 
class TestLineLogFormatter(TestCaseForLogFormatter):
 
714
        try:
 
715
            def bad_argument_prop_handler(revision):
 
716
                return {'custom_prop_name':revision.properties['a_prop']}
 
717
 
 
718
            log.properties_handler_registry.register(
 
719
                'bad_argument_prop_handler',
 
720
                bad_argument_prop_handler)
 
721
 
 
722
            self.assertRaises(AttributeError, formatter.show_properties,
 
723
                              'a revision', '')
 
724
 
 
725
            revision = b.repository.get_revision(b.last_revision())
 
726
            formatter.show_properties(revision, '')
 
727
            self.assertEqualDiff('''custom_prop_name: test_value\n''',
 
728
                                 sio.getvalue())
 
729
        finally:
 
730
            log.properties_handler_registry.remove(
 
731
                'bad_argument_prop_handler')
 
732
 
 
733
 
 
734
class TestLineLogFormatter(tests.TestCaseWithTransport):
800
735
 
801
736
    def test_line_log(self):
802
737
        """Line log should show revno
803
 
 
 
738
        
804
739
        bug #5162
805
740
        """
806
 
        wt = self.make_standard_commit('test-line-log',
807
 
                committer='Line-Log-Formatter Tester <test@line.log>',
808
 
                authors=[])
809
 
        self.assertFormatterResult("""\
810
 
1: Line-Log-Formatte... 2005-11-22 add a
811
 
""",
812
 
            wt.branch, log.LineLogFormatter)
 
741
        wt = self.make_branch_and_tree('.')
 
742
        b = wt.branch
 
743
        self.build_tree(['a'])
 
744
        wt.add('a')
 
745
        b.nick = 'test-line-log'
 
746
        wt.commit(message='add a',
 
747
                  timestamp=1132711707,
 
748
                  timezone=36000,
 
749
                  committer='Line-Log-Formatter Tester <test@line.log>')
 
750
        logfile = file('out.tmp', 'w+')
 
751
        formatter = log.LineLogFormatter(to_file=logfile)
 
752
        log.show_log(b, formatter)
 
753
        logfile.flush()
 
754
        logfile.seek(0)
 
755
        log_contents = logfile.read()
 
756
        self.assertEqualDiff('1: Line-Log-Formatte... 2005-11-23 add a\n',
 
757
                             log_contents)
813
758
 
814
759
    def test_trailing_newlines(self):
815
760
        wt = self.make_branch_and_tree('.')
816
 
        b = self.make_commits_with_trailing_newlines(wt)
817
 
        self.assertFormatterResult("""\
818
 
3: Joe Foo 2005-11-22 single line with trailing newline
819
 
2: Joe Foo 2005-11-22 multiline
820
 
1: Joe Foo 2005-11-22 simple log message
 
761
        b = make_commits_with_trailing_newlines(wt)
 
762
        sio = self.make_utf8_encoded_stringio()
 
763
        lf = log.LineLogFormatter(to_file=sio)
 
764
        log.show_log(b, lf)
 
765
        self.assertEqualDiff("""\
 
766
3: Joe Foo 2005-11-21 single line with trailing newline
 
767
2: Joe Bar 2005-11-21 multiline
 
768
1: Joe Foo 2005-11-21 simple log message
821
769
""",
822
 
            b, log.LineLogFormatter)
 
770
                             sio.getvalue())
 
771
 
 
772
    def _prepare_tree_with_merges(self, with_tags=False):
 
773
        wt = self.make_branch_and_memory_tree('.')
 
774
        wt.lock_write()
 
775
        self.addCleanup(wt.unlock)
 
776
        wt.add('')
 
777
        wt.commit('rev-1', rev_id='rev-1',
 
778
                  timestamp=1132586655, timezone=36000,
 
779
                  committer='Joe Foo <joe@foo.com>')
 
780
        wt.commit('rev-merged', rev_id='rev-2a',
 
781
                  timestamp=1132586700, timezone=36000,
 
782
                  committer='Joe Foo <joe@foo.com>')
 
783
        wt.set_parent_ids(['rev-1', 'rev-2a'])
 
784
        wt.branch.set_last_revision_info(1, 'rev-1')
 
785
        wt.commit('rev-2', rev_id='rev-2b',
 
786
                  timestamp=1132586800, timezone=36000,
 
787
                  committer='Joe Foo <joe@foo.com>')
 
788
        if with_tags:
 
789
            branch = wt.branch
 
790
            branch.tags.set_tag('v0.2', 'rev-2b')
 
791
            wt.commit('rev-3', rev_id='rev-3',
 
792
                      timestamp=1132586900, timezone=36000,
 
793
                      committer='Jane Foo <jane@foo.com>')
 
794
            branch.tags.set_tag('v1.0rc1', 'rev-3')
 
795
            branch.tags.set_tag('v1.0', 'rev-3')
 
796
        return wt
823
797
 
824
798
    def test_line_log_single_merge_revision(self):
825
799
        wt = self._prepare_tree_with_merges()
 
800
        logfile = self.make_utf8_encoded_stringio()
 
801
        formatter = log.LineLogFormatter(to_file=logfile)
826
802
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
827
 
        rev = revspec.in_history(wt.branch)
828
 
        self.assertFormatterResult("""\
 
803
        wtb = wt.branch
 
804
        rev = revspec.in_history(wtb)
 
805
        log.show_log(wtb, formatter, start_revision=rev, end_revision=rev)
 
806
        self.assertEqualDiff("""\
829
807
1.1.1: Joe Foo 2005-11-22 rev-merged
830
808
""",
831
 
            wt.branch, log.LineLogFormatter,
832
 
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
 
809
                             logfile.getvalue())
833
810
 
834
811
    def test_line_log_with_tags(self):
835
812
        wt = self._prepare_tree_with_merges(with_tags=True)
836
 
        self.assertFormatterResult("""\
837
 
3: Joe Foo 2005-11-22 {v1.0, v1.0rc1} rev-3
838
 
2: Joe Foo 2005-11-22 [merge] {v0.2} rev-2
839
 
1: Joe Foo 2005-11-22 rev-1
840
 
""",
841
 
            wt.branch, log.LineLogFormatter)
842
 
 
843
 
 
844
 
class TestLineLogFormatterWithMergeRevisions(TestCaseForLogFormatter):
845
 
 
846
 
    def test_line_merge_revs_log(self):
847
 
        """Line log should show revno
848
 
 
849
 
        bug #5162
850
 
        """
851
 
        wt = self.make_standard_commit('test-line-log',
852
 
                committer='Line-Log-Formatter Tester <test@line.log>',
853
 
                authors=[])
854
 
        self.assertFormatterResult("""\
855
 
1: Line-Log-Formatte... 2005-11-22 add a
856
 
""",
857
 
            wt.branch, log.LineLogFormatter)
858
 
 
859
 
    def test_line_merge_revs_log_single_merge_revision(self):
860
 
        wt = self._prepare_tree_with_merges()
861
 
        revspec = revisionspec.RevisionSpec.from_string('1.1.1')
862
 
        rev = revspec.in_history(wt.branch)
863
 
        self.assertFormatterResult("""\
864
 
1.1.1: Joe Foo 2005-11-22 rev-merged
865
 
""",
866
 
            wt.branch, log.LineLogFormatter,
867
 
            formatter_kwargs=dict(levels=0),
868
 
            show_log_kwargs=dict(start_revision=rev, end_revision=rev))
869
 
 
870
 
    def test_line_merge_revs_log_with_merges(self):
871
 
        wt = self._prepare_tree_with_merges()
872
 
        self.assertFormatterResult("""\
873
 
2: Joe Foo 2005-11-22 [merge] rev-2
874
 
  1.1.1: Joe Foo 2005-11-22 rev-merged
875
 
1: Joe Foo 2005-11-22 rev-1
876
 
""",
877
 
            wt.branch, log.LineLogFormatter,
878
 
            formatter_kwargs=dict(levels=0))
879
 
 
880
 
 
881
 
class TestGnuChangelogFormatter(TestCaseForLogFormatter):
882
 
 
883
 
    def test_gnu_changelog(self):
884
 
        wt = self.make_standard_commit('nicky', authors=[])
885
 
        self.assertFormatterResult('''\
886
 
2005-11-22  Lorem Ipsum  <test@example.com>
887
 
 
888
 
\tadd a
889
 
 
890
 
''',
891
 
            wt.branch, log.GnuChangelogLogFormatter)
892
 
 
893
 
    def test_with_authors(self):
894
 
        wt = self.make_standard_commit('nicky',
895
 
            authors=['Fooa Fooz <foo@example.com>',
896
 
                     'Bari Baro <bar@example.com>'])
897
 
        self.assertFormatterResult('''\
898
 
2005-11-22  Fooa Fooz  <foo@example.com>
899
 
 
900
 
\tadd a
901
 
 
902
 
''',
903
 
            wt.branch, log.GnuChangelogLogFormatter)
904
 
 
905
 
    def test_verbose(self):
906
 
        wt = self.make_standard_commit('nicky')
907
 
        self.assertFormatterResult('''\
908
 
2005-11-22  John Doe  <jdoe@example.com>
909
 
 
910
 
\t* a:
911
 
 
912
 
\tadd a
913
 
 
914
 
''',
915
 
            wt.branch, log.GnuChangelogLogFormatter,
916
 
            show_log_kwargs=dict(verbose=True))
917
 
 
918
 
class TestGetViewRevisions(tests.TestCaseWithTransport, TestLogMixin):
919
 
 
920
 
    def _get_view_revisions(self, *args, **kwargs):
921
 
        return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
922
 
                                    log.get_view_revisions, *args, **kwargs)
 
813
        logfile = self.make_utf8_encoded_stringio()
 
814
        formatter = log.LineLogFormatter(to_file=logfile)
 
815
        log.show_log(wt.branch, formatter)
 
816
        self.assertEqualDiff("""\
 
817
3: Jane Foo 2005-11-22 {v1.0, v1.0rc1} rev-3
 
818
2: Joe Foo 2005-11-22 {v0.2} rev-2
 
819
1: Joe Foo 2005-11-22 rev-1
 
820
""",
 
821
                             logfile.getvalue())
 
822
 
 
823
 
 
824
class TestGetViewRevisions(tests.TestCaseWithTransport):
923
825
 
924
826
    def make_tree_with_commits(self):
925
827
        """Create a tree with well-known revision ids"""
926
828
        wt = self.make_branch_and_tree('tree1')
927
 
        self.wt_commit(wt, 'commit one', rev_id='1')
928
 
        self.wt_commit(wt, 'commit two', rev_id='2')
929
 
        self.wt_commit(wt, 'commit three', rev_id='3')
 
829
        wt.commit('commit one', rev_id='1')
 
830
        wt.commit('commit two', rev_id='2')
 
831
        wt.commit('commit three', rev_id='3')
930
832
        mainline_revs = [None, '1', '2', '3']
931
833
        rev_nos = {'1': 1, '2': 2, '3': 3}
932
834
        return mainline_revs, rev_nos, wt
935
837
        """Create a tree with well-known revision ids and a merge"""
936
838
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
937
839
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
938
 
        self.wt_commit(tree2, 'four-a', rev_id='4a')
 
840
        tree2.commit('four-a', rev_id='4a')
939
841
        wt.merge_from_branch(tree2.branch)
940
 
        self.wt_commit(wt, 'four-b', rev_id='4b')
 
842
        wt.commit('four-b', rev_id='4b')
941
843
        mainline_revs.append('4b')
942
844
        rev_nos['4b'] = 4
943
845
        # 4a: 3.1.1
944
846
        return mainline_revs, rev_nos, wt
945
847
 
946
 
    def make_branch_with_many_merges(self):
 
848
    def make_tree_with_many_merges(self):
947
849
        """Create a tree with well-known revision ids"""
948
 
        builder = self.make_branch_builder('tree1')
949
 
        builder.start_series()
950
 
        builder.build_snapshot('1', None, [
951
 
            ('add', ('', 'TREE_ROOT', 'directory', '')),
952
 
            ('add', ('f', 'f-id', 'file', '1\n'))])
953
 
        builder.build_snapshot('2', ['1'], [])
954
 
        builder.build_snapshot('3a', ['2'], [
955
 
            ('modify', ('f-id', '1\n2\n3a\n'))])
956
 
        builder.build_snapshot('3b', ['2', '3a'], [
957
 
            ('modify', ('f-id', '1\n2\n3a\n'))])
958
 
        builder.build_snapshot('3c', ['2', '3b'], [
959
 
            ('modify', ('f-id', '1\n2\n3a\n'))])
960
 
        builder.build_snapshot('4a', ['3b'], [])
961
 
        builder.build_snapshot('4b', ['3c', '4a'], [])
962
 
        builder.finish_series()
963
 
 
964
 
        # 1
965
 
        # |
966
 
        # 2-.
967
 
        # |\ \
968
 
        # | | 3a
969
 
        # | |/
970
 
        # | 3b
971
 
        # |/|
972
 
        # 3c4a
973
 
        # |/
974
 
        # 4b
 
850
        wt = self.make_branch_and_tree('tree1')
 
851
        self.build_tree_contents([('tree1/f', '1\n')])
 
852
        wt.add(['f'], ['f-id'])
 
853
        wt.commit('commit one', rev_id='1')
 
854
        wt.commit('commit two', rev_id='2')
 
855
 
 
856
        tree3 = wt.bzrdir.sprout('tree3').open_workingtree()
 
857
        self.build_tree_contents([('tree3/f', '1\n2\n3a\n')])
 
858
        tree3.commit('commit three a', rev_id='3a')
 
859
 
 
860
        tree2 = wt.bzrdir.sprout('tree2').open_workingtree()
 
861
        tree2.merge_from_branch(tree3.branch)
 
862
        tree2.commit('commit three b', rev_id='3b')
 
863
 
 
864
        wt.merge_from_branch(tree2.branch)
 
865
        wt.commit('commit three c', rev_id='3c')
 
866
        tree2.commit('four-a', rev_id='4a')
 
867
 
 
868
        wt.merge_from_branch(tree2.branch)
 
869
        wt.commit('four-b', rev_id='4b')
975
870
 
976
871
        mainline_revs = [None, '1', '2', '3c', '4b']
977
872
        rev_nos = {'1':1, '2':2, '3c': 3, '4b':4}
984
879
            '4a': '2.2.2', # second commit tree 2
985
880
            '4b': '4', # merges 4a to main
986
881
            }
987
 
        return mainline_revs, rev_nos, builder.get_branch()
 
882
        return mainline_revs, rev_nos, wt
988
883
 
989
884
    def test_get_view_revisions_forward(self):
990
885
        """Test the get_view_revisions method"""
991
886
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
992
887
        wt.lock_read()
993
888
        self.addCleanup(wt.unlock)
994
 
        revisions = list(self._get_view_revisions(
 
889
        revisions = list(log.get_view_revisions(
995
890
                mainline_revs, rev_nos, wt.branch, 'forward'))
996
891
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0)],
997
892
                         revisions)
998
 
        revisions2 = list(self._get_view_revisions(
 
893
        revisions2 = list(log.get_view_revisions(
999
894
                mainline_revs, rev_nos, wt.branch, 'forward',
1000
895
                include_merges=False))
1001
896
        self.assertEqual(revisions, revisions2)
1005
900
        mainline_revs, rev_nos, wt = self.make_tree_with_commits()
1006
901
        wt.lock_read()
1007
902
        self.addCleanup(wt.unlock)
1008
 
        revisions = list(self._get_view_revisions(
 
903
        revisions = list(log.get_view_revisions(
1009
904
                mainline_revs, rev_nos, wt.branch, 'reverse'))
1010
905
        self.assertEqual([('3', '3', 0), ('2', '2', 0), ('1', '1', 0), ],
1011
906
                         revisions)
1012
 
        revisions2 = list(self._get_view_revisions(
 
907
        revisions2 = list(log.get_view_revisions(
1013
908
                mainline_revs, rev_nos, wt.branch, 'reverse',
1014
909
                include_merges=False))
1015
910
        self.assertEqual(revisions, revisions2)
1019
914
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
1020
915
        wt.lock_read()
1021
916
        self.addCleanup(wt.unlock)
1022
 
        revisions = list(self._get_view_revisions(
 
917
        revisions = list(log.get_view_revisions(
1023
918
                mainline_revs, rev_nos, wt.branch, 'forward'))
1024
919
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0),
1025
920
                          ('4b', '4', 0), ('4a', '3.1.1', 1)],
1026
921
                         revisions)
1027
 
        revisions = list(self._get_view_revisions(
 
922
        revisions = list(log.get_view_revisions(
1028
923
                mainline_revs, rev_nos, wt.branch, 'forward',
1029
924
                include_merges=False))
1030
925
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3', '3', 0),
1036
931
        mainline_revs, rev_nos, wt = self.make_tree_with_merges()
1037
932
        wt.lock_read()
1038
933
        self.addCleanup(wt.unlock)
1039
 
        revisions = list(self._get_view_revisions(
 
934
        revisions = list(log.get_view_revisions(
1040
935
                mainline_revs, rev_nos, wt.branch, 'reverse'))
1041
936
        self.assertEqual([('4b', '4', 0), ('4a', '3.1.1', 1),
1042
937
                          ('3', '3', 0), ('2', '2', 0), ('1', '1', 0)],
1043
938
                         revisions)
1044
 
        revisions = list(self._get_view_revisions(
 
939
        revisions = list(log.get_view_revisions(
1045
940
                mainline_revs, rev_nos, wt.branch, 'reverse',
1046
941
                include_merges=False))
1047
942
        self.assertEqual([('4b', '4', 0), ('3', '3', 0), ('2', '2', 0),
1050
945
 
1051
946
    def test_get_view_revisions_merge2(self):
1052
947
        """Test get_view_revisions when there are merges"""
1053
 
        mainline_revs, rev_nos, b = self.make_branch_with_many_merges()
1054
 
        b.lock_read()
1055
 
        self.addCleanup(b.unlock)
1056
 
        revisions = list(self._get_view_revisions(
1057
 
                mainline_revs, rev_nos, b, 'forward'))
 
948
        mainline_revs, rev_nos, wt = self.make_tree_with_many_merges()
 
949
        wt.lock_read()
 
950
        self.addCleanup(wt.unlock)
 
951
        revisions = list(log.get_view_revisions(
 
952
                mainline_revs, rev_nos, wt.branch, 'forward'))
1058
953
        expected = [('1', '1', 0), ('2', '2', 0), ('3c', '3', 0),
1059
 
                    ('3b', '2.2.1', 1), ('3a', '2.1.1', 2), ('4b', '4', 0),
 
954
                    ('3a', '2.1.1', 1), ('3b', '2.2.1', 1), ('4b', '4', 0),
1060
955
                    ('4a', '2.2.2', 1)]
1061
956
        self.assertEqual(expected, revisions)
1062
 
        revisions = list(self._get_view_revisions(
1063
 
                mainline_revs, rev_nos, b, 'forward',
 
957
        revisions = list(log.get_view_revisions(
 
958
                mainline_revs, rev_nos, wt.branch, 'forward',
1064
959
                include_merges=False))
1065
960
        self.assertEqual([('1', '1', 0), ('2', '2', 0), ('3c', '3', 0),
1066
961
                          ('4b', '4', 0)],
1067
962
                         revisions)
1068
963
 
 
964
 
1069
965
    def test_file_id_for_range(self):
1070
 
        mainline_revs, rev_nos, b = self.make_branch_with_many_merges()
1071
 
        b.lock_read()
1072
 
        self.addCleanup(b.unlock)
 
966
        mainline_revs, rev_nos, wt = self.make_tree_with_many_merges()
 
967
        wt.lock_read()
 
968
        self.addCleanup(wt.unlock)
1073
969
 
1074
970
        def rev_from_rev_id(revid, branch):
1075
971
            revspec = revisionspec.RevisionSpec.from_string('revid:%s' % revid)
1076
972
            return revspec.in_history(branch)
1077
973
 
1078
974
        def view_revs(start_rev, end_rev, file_id, direction):
1079
 
            revs = self.applyDeprecated(
1080
 
                symbol_versioning.deprecated_in((2, 2, 0)),
1081
 
                log.calculate_view_revisions,
1082
 
                b,
 
975
            revs = log.calculate_view_revisions(
 
976
                wt.branch,
1083
977
                start_rev, # start_revision
1084
978
                end_rev, # end_revision
1085
979
                direction, # direction
1086
980
                file_id, # specific_fileid
1087
981
                True, # generate_merge_revisions
 
982
                True, # allow_single_merge_revision
1088
983
                )
1089
984
            return revs
1090
985
 
1091
 
        rev_3a = rev_from_rev_id('3a', b)
1092
 
        rev_4b = rev_from_rev_id('4b', b)
1093
 
        self.assertEqual([('3c', '3', 0), ('3b', '2.2.1', 1),
1094
 
                          ('3a', '2.1.1', 2)],
 
986
        rev_3a = rev_from_rev_id('3a', wt.branch)
 
987
        rev_4b = rev_from_rev_id('4b', wt.branch)
 
988
        self.assertEqual([('3c', '3', 0), ('3a', '2.1.1', 1)],
1095
989
                          view_revs(rev_3a, rev_4b, 'f-id', 'reverse'))
1096
 
        # Note: 3c still appears before 3a here because of depth-based sorting
1097
 
        self.assertEqual([('3c', '3', 0), ('3b', '2.2.1', 1),
1098
 
                          ('3a', '2.1.1', 2)],
 
990
        # Note that the depth is 0 for 3a because depths are normalized, but
 
991
        # there is still a bug somewhere... most probably in
 
992
        # _filter_revision_range and/or get_view_revisions still around a bad
 
993
        # use of reverse_by_depth
 
994
        self.assertEqual([('3a', '2.1.1', 0)],
1099
995
                          view_revs(rev_3a, rev_4b, 'f-id', 'forward'))
1100
996
 
1101
997
 
1102
998
class TestGetRevisionsTouchingFileID(tests.TestCaseWithTransport):
1103
999
 
1104
 
    def get_view_revisions(self, *args):
1105
 
        return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
1106
 
                                    log.get_view_revisions, *args)
1107
 
 
1108
1000
    def create_tree_with_single_merge(self):
1109
1001
        """Create a branch with a moderate layout.
1110
1002
 
1128
1020
        #       use it. Since 'log' only uses the tree in a readonly
1129
1021
        #       fashion, it seems a shame to regenerate an identical
1130
1022
        #       tree for each test.
1131
 
        # TODO: vila 20100122 One way to address the shame above will be to
1132
 
        #       create a memory tree during test parametrization and give a
1133
 
        #       *copy* of this tree to each test. Copying a memory tree ought
1134
 
        #       to be cheap, at least cheaper than creating them with such
1135
 
        #       complex setups.
1136
1023
        tree = self.make_branch_and_tree('tree')
1137
1024
        tree.lock_write()
1138
1025
        self.addCleanup(tree.unlock)
1213
1100
        mainline = tree.branch.revision_history()
1214
1101
        mainline.insert(0, None)
1215
1102
        revnos = dict((rev, idx+1) for idx, rev in enumerate(mainline))
1216
 
        view_revs_iter = self.get_view_revisions(
1217
 
            mainline, revnos, tree.branch, 'reverse', True)
 
1103
        view_revs_iter = log.get_view_revisions(mainline, revnos, tree.branch,
 
1104
                                                'reverse', True)
1218
1105
        actual_revs = log._filter_revisions_touching_file_id(
1219
 
            tree.branch, file_id, list(view_revs_iter))
 
1106
                            tree.branch,
 
1107
                            file_id,
 
1108
                            list(view_revs_iter))
1220
1109
        self.assertEqual(revisions, [r for r, revno, depth in actual_revs])
1221
1110
 
1222
1111
    def test_file_id_f1(self):
1250
1139
        self.assertAllRevisionsForFileID(tree, 'f1-id', ['XX', 'B', 'A'])
1251
1140
        self.assertAllRevisionsForFileID(tree, 'f2-id', ['D', 'C', 'A'])
1252
1141
 
1253
 
    def test_unknown_file_id(self):
1254
 
        tree = self.create_tree_with_single_merge()
1255
 
        self.assertAllRevisionsForFileID(tree, 'unknown', [])
1256
 
 
1257
 
    def test_empty_branch_unknown_file_id(self):
1258
 
        tree = self.make_branch_and_tree('tree')
1259
 
        self.assertAllRevisionsForFileID(tree, 'unknown', [])
1260
 
 
1261
1142
 
1262
1143
class TestShowChangedRevisions(tests.TestCaseWithTransport):
1263
1144
 
1274
1155
 
1275
1156
class TestLogFormatter(tests.TestCase):
1276
1157
 
1277
 
    def setUp(self):
1278
 
        super(TestLogFormatter, self).setUp()
1279
 
        self.rev = revision.Revision('a-id')
1280
 
        self.lf = log.LogFormatter(None)
1281
 
 
1282
1158
    def test_short_committer(self):
1283
 
        def assertCommitter(expected, committer):
1284
 
            self.rev.committer = committer
1285
 
            self.assertEqual(expected, self.lf.short_committer(self.rev))
1286
 
 
1287
 
        assertCommitter('John Doe', 'John Doe <jdoe@example.com>')
1288
 
        assertCommitter('John Smith', 'John Smith <jsmith@example.com>')
1289
 
        assertCommitter('John Smith', 'John Smith')
1290
 
        assertCommitter('jsmith@example.com', 'jsmith@example.com')
1291
 
        assertCommitter('jsmith@example.com', '<jsmith@example.com>')
1292
 
        assertCommitter('John Smith', 'John Smith jsmith@example.com')
 
1159
        rev = revision.Revision('a-id')
 
1160
        rev.committer = 'John Doe <jdoe@example.com>'
 
1161
        lf = log.LogFormatter(None)
 
1162
        self.assertEqual('John Doe', lf.short_committer(rev))
 
1163
        rev.committer = 'John Smith <jsmith@example.com>'
 
1164
        self.assertEqual('John Smith', lf.short_committer(rev))
 
1165
        rev.committer = 'John Smith'
 
1166
        self.assertEqual('John Smith', lf.short_committer(rev))
 
1167
        rev.committer = 'jsmith@example.com'
 
1168
        self.assertEqual('jsmith@example.com', lf.short_committer(rev))
 
1169
        rev.committer = '<jsmith@example.com>'
 
1170
        self.assertEqual('jsmith@example.com', lf.short_committer(rev))
 
1171
        rev.committer = 'John Smith jsmith@example.com'
 
1172
        self.assertEqual('John Smith', lf.short_committer(rev))
1293
1173
 
1294
1174
    def test_short_author(self):
1295
 
        def assertAuthor(expected, author):
1296
 
            self.rev.properties['author'] = author
1297
 
            self.assertEqual(expected, self.lf.short_author(self.rev))
1298
 
 
1299
 
        assertAuthor('John Smith', 'John Smith <jsmith@example.com>')
1300
 
        assertAuthor('John Smith', 'John Smith')
1301
 
        assertAuthor('jsmith@example.com', 'jsmith@example.com')
1302
 
        assertAuthor('jsmith@example.com', '<jsmith@example.com>')
1303
 
        assertAuthor('John Smith', 'John Smith jsmith@example.com')
1304
 
 
1305
 
    def test_short_author_from_committer(self):
1306
 
        self.rev.committer = 'John Doe <jdoe@example.com>'
1307
 
        self.assertEqual('John Doe', self.lf.short_author(self.rev))
1308
 
 
1309
 
    def test_short_author_from_authors(self):
1310
 
        self.rev.properties['authors'] = ('John Smith <jsmith@example.com>\n'
1311
 
                                          'Jane Rey <jrey@example.com>')
1312
 
        self.assertEqual('John Smith', self.lf.short_author(self.rev))
 
1175
        rev = revision.Revision('a-id')
 
1176
        rev.committer = 'John Doe <jdoe@example.com>'
 
1177
        lf = log.LogFormatter(None)
 
1178
        self.assertEqual('John Doe', lf.short_author(rev))
 
1179
        rev.properties['author'] = 'John Smith <jsmith@example.com>'
 
1180
        self.assertEqual('John Smith', lf.short_author(rev))
 
1181
        rev.properties['author'] = 'John Smith'
 
1182
        self.assertEqual('John Smith', lf.short_author(rev))
 
1183
        rev.properties['author'] = 'jsmith@example.com'
 
1184
        self.assertEqual('jsmith@example.com', lf.short_author(rev))
 
1185
        rev.properties['author'] = '<jsmith@example.com>'
 
1186
        self.assertEqual('jsmith@example.com', lf.short_author(rev))
 
1187
        rev.properties['author'] = 'John Smith jsmith@example.com'
 
1188
        self.assertEqual('John Smith', lf.short_author(rev))
1313
1189
 
1314
1190
 
1315
1191
class TestReverseByDepth(tests.TestCase):
1461
1337
        log.show_branch_change(tree.branch, s, 3, '3b')
1462
1338
        self.assertContainsRe(s.getvalue(), 'Removed Revisions:')
1463
1339
        self.assertNotContainsRe(s.getvalue(), 'Added Revisions:')
1464
 
 
1465
 
 
1466
 
 
1467
 
class TestLogWithBugs(TestCaseForLogFormatter, TestLogMixin):
1468
 
 
1469
 
    def setUp(self):
1470
 
        TestCaseForLogFormatter.setUp(self)
1471
 
        log.properties_handler_registry.register(
1472
 
            'bugs_properties_handler',
1473
 
            log._bugs_properties_handler)
1474
 
 
1475
 
    def make_commits_with_bugs(self):
1476
 
        """Helper method for LogFormatter tests"""
1477
 
        tree = self.make_branch_and_tree(u'.')
1478
 
        self.build_tree(['a', 'b'])
1479
 
        tree.add('a')
1480
 
        self.wt_commit(tree, 'simple log message', rev_id='a1',
1481
 
                       revprops={'bugs': 'test://bug/id fixed'})
1482
 
        tree.add('b')
1483
 
        self.wt_commit(tree, 'multiline\nlog\nmessage\n', rev_id='a2',
1484
 
                       authors=['Joe Bar <joe@bar.com>'],
1485
 
                       revprops={'bugs': 'test://bug/id fixed\n'
1486
 
                                 'test://bug/2 fixed'})
1487
 
        return tree
1488
 
 
1489
 
 
1490
 
    def test_long_bugs(self):
1491
 
        tree = self.make_commits_with_bugs()
1492
 
        self.assertFormatterResult("""\
1493
 
------------------------------------------------------------
1494
 
revno: 2
1495
 
fixes bug(s): test://bug/id test://bug/2
1496
 
author: Joe Bar <joe@bar.com>
1497
 
committer: Joe Foo <joe@foo.com>
1498
 
branch nick: work
1499
 
timestamp: Tue 2005-11-22 00:00:01 +0000
1500
 
message:
1501
 
  multiline
1502
 
  log
1503
 
  message
1504
 
------------------------------------------------------------
1505
 
revno: 1
1506
 
fixes bug(s): test://bug/id
1507
 
committer: Joe Foo <joe@foo.com>
1508
 
branch nick: work
1509
 
timestamp: Tue 2005-11-22 00:00:00 +0000
1510
 
message:
1511
 
  simple log message
1512
 
""",
1513
 
            tree.branch, log.LongLogFormatter)
1514
 
 
1515
 
    def test_short_bugs(self):
1516
 
        tree = self.make_commits_with_bugs()
1517
 
        self.assertFormatterResult("""\
1518
 
    2 Joe Bar\t2005-11-22
1519
 
      fixes bug(s): test://bug/id test://bug/2
1520
 
      multiline
1521
 
      log
1522
 
      message
1523
 
 
1524
 
    1 Joe Foo\t2005-11-22
1525
 
      fixes bug(s): test://bug/id
1526
 
      simple log message
1527
 
 
1528
 
""",
1529
 
            tree.branch, log.ShortLogFormatter)
1530
 
 
1531
 
    def test_wrong_bugs_property(self):
1532
 
        tree = self.make_branch_and_tree(u'.')
1533
 
        self.build_tree(['foo'])
1534
 
        self.wt_commit(tree, 'simple log message', rev_id='a1',
1535
 
                       revprops={'bugs': 'test://bug/id invalid_value'})
1536
 
        self.assertFormatterResult("""\
1537
 
    1 Joe Foo\t2005-11-22
1538
 
      simple log message
1539
 
 
1540
 
""",
1541
 
            tree.branch, log.ShortLogFormatter)
1542
 
 
1543
 
    def test_bugs_handler_present(self):
1544
 
        self.properties_handler_registry.get('bugs_properties_handler')
1545
 
 
1546
 
class TestLogExcludeAncestry(tests.TestCaseWithTransport):
1547
 
 
1548
 
    def make_branch_with_alternate_ancestries(self, relpath='.'):
1549
 
        # See test_merge_sorted_exclude_ancestry below for the difference with
1550
 
        # bt.per_branch.test_iter_merge_sorted_revision.
1551
 
        # TestIterMergeSortedRevisionsBushyGraph. 
1552
 
        # make_branch_with_alternate_ancestries
1553
 
        # and test_merge_sorted_exclude_ancestry
1554
 
        # See the FIXME in assertLogRevnos too.
1555
 
        builder = branchbuilder.BranchBuilder(self.get_transport(relpath))
1556
 
        # 1
1557
 
        # |\
1558
 
        # 2 \
1559
 
        # |  |
1560
 
        # |  1.1.1
1561
 
        # |  | \
1562
 
        # |  |  1.2.1
1563
 
        # |  | /
1564
 
        # |  1.1.2
1565
 
        # | /
1566
 
        # 3
1567
 
        builder.start_series()
1568
 
        builder.build_snapshot('1', None, [
1569
 
            ('add', ('', 'TREE_ROOT', 'directory', '')),])
1570
 
        builder.build_snapshot('1.1.1', ['1'], [])
1571
 
        builder.build_snapshot('2', ['1'], [])
1572
 
        builder.build_snapshot('1.2.1', ['1.1.1'], [])
1573
 
        builder.build_snapshot('1.1.2', ['1.1.1', '1.2.1'], [])
1574
 
        builder.build_snapshot('3', ['2', '1.1.2'], [])
1575
 
        builder.finish_series()
1576
 
        br = builder.get_branch()
1577
 
        br.lock_read()
1578
 
        self.addCleanup(br.unlock)
1579
 
        return br
1580
 
 
1581
 
    def assertLogRevnos(self, expected_revnos, b, start, end,
1582
 
                        exclude_common_ancestry):
1583
 
        # FIXME: the layering in log makes it hard to test intermediate levels,
1584
 
        # I wish adding filters with their parameters were easier...
1585
 
        # -- vila 20100413
1586
 
        iter_revs = log._calc_view_revisions(
1587
 
            b, start, end, direction='reverse',
1588
 
            generate_merge_revisions=True,
1589
 
            exclude_common_ancestry=exclude_common_ancestry)
1590
 
        self.assertEqual(expected_revnos,
1591
 
                         [revid for revid, revno, depth in iter_revs])
1592
 
 
1593
 
    def test_merge_sorted_exclude_ancestry(self):
1594
 
        b = self.make_branch_with_alternate_ancestries()
1595
 
        self.assertLogRevnos(['3', '1.1.2', '1.2.1', '1.1.1', '2', '1'],
1596
 
                             b, '1', '3', False)
1597
 
        # '2' is part of the '3' ancestry but not part of '1.1.1' ancestry so
1598
 
        # it should be mentioned even if merge_sort order will make it appear
1599
 
        # after 1.1.1
1600
 
        self.assertLogRevnos(['3', '1.1.2', '1.2.1', '2'],
1601
 
                             b, '1.1.1', '3', True)
1602
 
 
1603