← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_log.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_log.py
1
 
# Copyright (C) 2005, 2006, 2007, 2009 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
17
17
 
18
18
"""Black-box tests for bzr log."""
19
19
 
 
20
from itertools import izip
20
21
import os
21
22
import re
22
23
 
23
24
from bzrlib import (
 
25
    branchbuilder,
 
26
    errors,
 
27
    log,
24
28
    osutils,
25
29
    tests,
26
30
    )
27
 
from bzrlib.tests import test_log
28
 
 
29
 
 
30
 
class TestLog(tests.TestCaseWithTransport):
31
 
 
32
 
    def setUp(self):
33
 
        super(TestLog, self).setUp()
34
 
        self.timezone = 0 # UTC
35
 
        self.timestamp = 1132617600 # Mon 2005-11-22 00:00:00 +0000
 
31
from bzrlib.tests import (
 
32
    script,
 
33
    test_log,
 
34
    )
 
35
 
 
36
 
 
37
class TestLog(tests.TestCaseWithTransport, test_log.TestLogMixin):
36
38
 
37
39
    def make_minimal_branch(self, path='.', format=None):
38
40
        tree = self.make_branch_and_tree(path, format=format)
63
65
        tree.commit(message='merge')
64
66
        return tree
65
67
 
66
 
    def assertRevnos(self, log, must_have=(), must_not_have=()):
67
 
        """Check if revnos are in or not in the log output"""
68
 
        for revno in must_have:
69
 
            self.assertTrue(('revno: %s\n' % revno) in log,
70
 
                'Does not contain expected revno %s' % revno)
71
 
        for revno in must_not_have:
72
 
            self.assertFalse(('revno: %s\n' % revno) in log,
73
 
                'Contains unexpected revno %s' % revno)
74
 
 
75
 
    def commit_options(self):
76
 
        """Use some mostly fixed values for commits to simplify tests.
77
 
 
78
 
        Tests can use this function to get some commit attributes. The time
79
 
        stamp is incremented at each commit.
80
 
        """
81
 
        self.timestamp += 1 # 1 second between each commit
82
 
        return dict(committer='Lorem Ipsum <joe@foo.com>',
83
 
                 timezone=self.timezone,
84
 
                 timestamp=self.timestamp,
85
 
                 )
86
 
 
87
 
    def check_log(self, expected, args, working_dir='level0'):
88
 
        out, err = self.run_bzr(['log', '--timezone', 'utc'] + args,
89
 
                                working_dir=working_dir)
90
 
        self.assertEqual('', err)
91
 
        self.assertEqualDiff(expected, test_log.normalize_log(out))
92
 
 
93
 
 
94
 
class TestLogRevSpecs(TestLog):
 
68
 
 
69
class TestLogWithLogCatcher(TestLog):
 
70
 
 
71
    def setUp(self):
 
72
        super(TestLogWithLogCatcher, self).setUp()
 
73
        # Capture log formatter creations
 
74
        class MyLogFormatter(test_log.LogCatcher):
 
75
 
 
76
            def __new__(klass, *args, **kwargs):
 
77
                self.log_catcher = test_log.LogCatcher(*args, **kwargs)
 
78
                # Always return our own log formatter
 
79
                return self.log_catcher
 
80
 
 
81
        def getme(branch):
 
82
                # Always return our own log formatter class hijacking the
 
83
                # default behavior (which requires setting up a config
 
84
                # variable)
 
85
            return MyLogFormatter
 
86
        self.overrideAttr(log.log_formatter_registry, 'get_default', getme)
 
87
 
 
88
    def get_captured_revisions(self):
 
89
        return self.log_catcher.revisions
 
90
 
 
91
    def assertLogRevnos(self, args, expected_revnos, working_dir='.'):
 
92
        self.run_bzr(['log'] + args, working_dir=working_dir)
 
93
        self.assertEqual(expected_revnos,
 
94
                         [r.revno for r in self.get_captured_revisions()])
 
95
 
 
96
    def assertLogRevnosAndDepths(self, args, expected_revnos_and_depths,
 
97
                                working_dir='.'):
 
98
        self.run_bzr(['log'] + args, working_dir=working_dir)
 
99
        self.assertEqual(expected_revnos_and_depths,
 
100
                         [(r.revno, r.merge_depth)
 
101
                           for r in self.get_captured_revisions()])
 
102
 
 
103
 
 
104
class TestLogRevSpecs(TestLogWithLogCatcher):
 
105
 
 
106
    def test_log_no_revspec(self):
 
107
        self.make_linear_branch()
 
108
        self.assertLogRevnos([], ['3', '2', '1'])
95
109
 
96
110
    def test_log_null_end_revspec(self):
97
111
        self.make_linear_branch()
98
 
        log = self.run_bzr(['log'])[0]
99
 
        self.assertTrue('revno: 1\n' in log)
100
 
        self.assertTrue('revno: 2\n' in log)
101
 
        self.assertTrue('revno: 3\n' in log)
102
 
        self.assertTrue('message:\n  message1\n' in log)
103
 
        self.assertTrue('message:\n  message2\n' in log)
104
 
        self.assertTrue('message:\n  message3\n' in log)
105
 
 
106
 
        full_log = self.run_bzr(['log'])[0]
107
 
        log = self.run_bzr("log -r 1..")[0]
108
 
        self.assertEqualDiff(log, full_log)
 
112
        self.assertLogRevnos(['-r1..'], ['3', '2', '1'])
109
113
 
110
114
    def test_log_null_begin_revspec(self):
111
115
        self.make_linear_branch()
112
 
        full_log = self.run_bzr(['log'])[0]
113
 
        log = self.run_bzr("log -r ..3")[0]
114
 
        self.assertEqualDiff(full_log, log)
 
116
        self.assertLogRevnos(['-r..3'], ['3', '2', '1'])
115
117
 
116
118
    def test_log_null_both_revspecs(self):
117
119
        self.make_linear_branch()
118
 
        full_log = self.run_bzr(['log'])[0]
119
 
        log = self.run_bzr("log -r ..")[0]
120
 
        self.assertEqualDiff(full_log, log)
121
 
 
122
 
    def test_log_zero_revspec(self):
123
 
        self.make_minimal_branch()
124
 
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
125
 
                           ['log', '-r0'])
126
 
 
127
 
    def test_log_zero_begin_revspec(self):
128
 
        self.make_linear_branch()
129
 
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
130
 
                           ['log', '-r0..2'])
131
 
 
132
 
    def test_log_zero_end_revspec(self):
133
 
        self.make_linear_branch()
134
 
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
135
 
                           ['log', '-r-2..0'])
 
120
        self.assertLogRevnos(['-r..'], ['3', '2', '1'])
136
121
 
137
122
    def test_log_negative_begin_revspec_full_log(self):
138
123
        self.make_linear_branch()
139
 
        full_log = self.run_bzr(['log'])[0]
140
 
        log = self.run_bzr("log -r -3..")[0]
141
 
        self.assertEqualDiff(full_log, log)
 
124
        self.assertLogRevnos(['-r-3..'], ['3', '2', '1'])
142
125
 
143
126
    def test_log_negative_both_revspec_full_log(self):
144
127
        self.make_linear_branch()
145
 
        full_log = self.run_bzr(['log'])[0]
146
 
        log = self.run_bzr("log -r -3..-1")[0]
147
 
        self.assertEqualDiff(full_log, log)
 
128
        self.assertLogRevnos(['-r-3..-1'], ['3', '2', '1'])
148
129
 
149
130
    def test_log_negative_both_revspec_partial(self):
150
131
        self.make_linear_branch()
151
 
        log = self.run_bzr("log -r -3..-2")[0]
152
 
        self.assertTrue('revno: 1\n' in log)
153
 
        self.assertTrue('revno: 2\n' in log)
154
 
        self.assertTrue('revno: 3\n' not in log)
 
132
        self.assertLogRevnos(['-r-3..-2'], ['2', '1'])
155
133
 
156
134
    def test_log_negative_begin_revspec(self):
157
135
        self.make_linear_branch()
158
 
        log = self.run_bzr("log -r -2..")[0]
159
 
        self.assertTrue('revno: 1\n' not in log)
160
 
        self.assertTrue('revno: 2\n' in log)
161
 
        self.assertTrue('revno: 3\n' in log)
 
136
        self.assertLogRevnos(['-r-2..'], ['3', '2'])
162
137
 
163
138
    def test_log_positive_revspecs(self):
164
139
        self.make_linear_branch()
165
 
        full_log = self.run_bzr(['log'])[0]
166
 
        log = self.run_bzr("log -r 1..3")[0]
167
 
        self.assertEqualDiff(full_log, log)
 
140
        self.assertLogRevnos(['-r1..3'], ['3', '2', '1'])
168
141
 
169
142
    def test_log_dotted_revspecs(self):
170
143
        self.make_merged_branch()
171
 
        log = self.run_bzr("log -n0 -r 1..1.1.1")[0]
172
 
        self.assertRevnos(log, (1, '1.1.1'), (2, 3, '1.1.2', 4))
173
 
 
174
 
    def test_log_reversed_revspecs(self):
175
 
        self.make_linear_branch()
176
 
        self.run_bzr_error(('bzr: ERROR: Start revision must be older than '
177
 
                            'the end revision.\n',),
178
 
                           ['log', '-r3..1'])
179
 
 
180
 
    def test_log_reversed_dotted_revspecs(self):
181
 
        self.make_merged_branch()
182
 
        self.run_bzr_error(('bzr: ERROR: Start revision not found in '
183
 
                            'left-hand history of end revision.\n',),
184
 
                           "log -r 1.1.1..1")
 
144
        self.assertLogRevnos(['-n0', '-r1..1.1.1'], ['1.1.1', '1'])
 
145
 
 
146
    def test_log_limit(self):
 
147
        tree = self.make_branch_and_tree('.')
 
148
        # We want more commits than our batch size starts at
 
149
        for pos in range(10):
 
150
            tree.commit("%s" % pos)
 
151
        self.assertLogRevnos(['--limit', '2'], ['10', '9'])
 
152
 
 
153
    def test_log_limit_short(self):
 
154
        self.make_linear_branch()
 
155
        self.assertLogRevnos(['-l', '2'], ['3', '2'])
 
156
 
 
157
    def test_log_change_revno(self):
 
158
        self.make_linear_branch()
 
159
        self.assertLogRevnos(['-c1'], ['1'])
 
160
 
 
161
    def test_branch_revspec(self):
 
162
        foo = self.make_branch_and_tree('foo')
 
163
        bar = self.make_branch_and_tree('bar')
 
164
        self.build_tree(['foo/foo.txt', 'bar/bar.txt'])
 
165
        foo.add('foo.txt')
 
166
        bar.add('bar.txt')
 
167
        foo.commit(message='foo')
 
168
        bar.commit(message='bar')
 
169
        self.run_bzr('log -r branch:../bar', working_dir='foo')
 
170
        self.assertEqual([bar.branch.get_rev_id(1)],
 
171
                         [r.rev.revision_id
 
172
                          for r in self.get_captured_revisions()])
 
173
 
 
174
 
 
175
class TestLogExcludeCommonAncestry(TestLogWithLogCatcher):
 
176
 
 
177
    def test_exclude_common_ancestry_simple_revnos(self):
 
178
        self.make_linear_branch()
 
179
        self.assertLogRevnos(['-r1..3', '--exclude-common-ancestry'],
 
180
                             ['3', '2'])
 
181
 
 
182
 
 
183
class TestLogMergedLinearAncestry(TestLogWithLogCatcher):
 
184
 
 
185
    def setUp(self):
 
186
        super(TestLogMergedLinearAncestry, self).setUp()
 
187
        # FIXME: Using a MemoryTree would be even better here (but until we
 
188
        # stop calling run_bzr, there is no point) --vila 100118.
 
189
        builder = branchbuilder.BranchBuilder(self.get_transport())
 
190
        builder.start_series()
 
191
        # 1
 
192
        # | \
 
193
        # 2  1.1.1
 
194
        # | / |
 
195
        # 3  1.1.2
 
196
        # |   |
 
197
        # |  1.1.3
 
198
        # | / |
 
199
        # 4  1.1.4
 
200
        # | /
 
201
        # 5
 
202
 
 
203
        # mainline
 
204
        builder.build_snapshot('1', None, [
 
205
            ('add', ('', 'root-id', 'directory', ''))])
 
206
        builder.build_snapshot('2', ['1'], [])
 
207
        # branch
 
208
        builder.build_snapshot('1.1.1', ['1'], [])
 
209
        # merge branch into mainline
 
210
        builder.build_snapshot('3', ['2', '1.1.1'], [])
 
211
        # new commits in branch
 
212
        builder.build_snapshot('1.1.2', ['1.1.1'], [])
 
213
        builder.build_snapshot('1.1.3', ['1.1.2'], [])
 
214
        # merge branch into mainline
 
215
        builder.build_snapshot('4', ['3', '1.1.3'], [])
 
216
        # merge mainline into branch
 
217
        builder.build_snapshot('1.1.4', ['1.1.3', '4'], [])
 
218
        # merge branch into mainline
 
219
        builder.build_snapshot('5', ['4', '1.1.4'], [])
 
220
        builder.finish_series()
 
221
 
 
222
    def test_n0(self):
 
223
        self.assertLogRevnos(['-n0', '-r1.1.1..1.1.4'],
 
224
                             ['1.1.4', '4', '1.1.3', '1.1.2', '3', '1.1.1'])
 
225
    def test_n0_forward(self):
 
226
        self.assertLogRevnos(['-n0', '-r1.1.1..1.1.4', '--forward'],
 
227
                             ['3', '1.1.1', '4', '1.1.2', '1.1.3', '1.1.4'])
 
228
 
 
229
    def test_n1(self):
 
230
        # starting from 1.1.4 we follow the left-hand ancestry
 
231
        self.assertLogRevnos(['-n1', '-r1.1.1..1.1.4'],
 
232
                             ['1.1.4', '1.1.3', '1.1.2', '1.1.1'])
 
233
 
 
234
    def test_n1_forward(self):
 
235
        self.assertLogRevnos(['-n1', '-r1.1.1..1.1.4', '--forward'],
 
236
                             ['1.1.1', '1.1.2', '1.1.3', '1.1.4'])
 
237
 
 
238
 
 
239
class Test_GenerateAllRevisions(TestLogWithLogCatcher):
 
240
 
 
241
    def setUp(self):
 
242
        super(Test_GenerateAllRevisions, self).setUp()
 
243
        builder = self.make_branch_with_many_merges()
 
244
        b = builder.get_branch()
 
245
        b.lock_read()
 
246
        self.addCleanup(b.unlock)
 
247
        self.branch = b
 
248
 
 
249
    def make_branch_with_many_merges(self, path='.', format=None):
 
250
        builder = branchbuilder.BranchBuilder(self.get_transport())
 
251
        builder.start_series()
 
252
        # The graph below may look a bit complicated (and it may be but I've
 
253
        # banged my head enough on it) but the bug requires at least dotted
 
254
        # revnos *and* merged revisions below that.
 
255
        builder.build_snapshot('1', None, [
 
256
            ('add', ('', 'root-id', 'directory', ''))])
 
257
        builder.build_snapshot('2', ['1'], [])
 
258
        builder.build_snapshot('1.1.1', ['1'], [])
 
259
        builder.build_snapshot('2.1.1', ['2'], [])
 
260
        builder.build_snapshot('3', ['2', '1.1.1'], [])
 
261
        builder.build_snapshot('2.1.2', ['2.1.1'], [])
 
262
        builder.build_snapshot('2.2.1', ['2.1.1'], [])
 
263
        builder.build_snapshot('2.1.3', ['2.1.2', '2.2.1'], [])
 
264
        builder.build_snapshot('4', ['3', '2.1.3'], [])
 
265
        builder.build_snapshot('5', ['4', '2.1.2'], [])
 
266
        builder.finish_series()
 
267
        return builder
 
268
 
 
269
    def test_not_an_ancestor(self):
 
270
        self.assertRaises(errors.BzrCommandError,
 
271
                          log._generate_all_revisions,
 
272
                          self.branch, '1.1.1', '2.1.3', 'reverse',
 
273
                          delayed_graph_generation=True)
 
274
 
 
275
    def test_wrong_order(self):
 
276
        self.assertRaises(errors.BzrCommandError,
 
277
                          log._generate_all_revisions,
 
278
                          self.branch, '5', '2.1.3', 'reverse',
 
279
                          delayed_graph_generation=True)
 
280
 
 
281
    def test_no_start_rev_id_with_end_rev_id_being_a_merge(self):
 
282
        revs = log._generate_all_revisions(
 
283
            self.branch, None, '2.1.3',
 
284
            'reverse', delayed_graph_generation=True)
 
285
 
 
286
 
 
287
class TestLogRevSpecsWithPaths(TestLogWithLogCatcher):
 
288
 
 
289
    def test_log_revno_n_path_wrong_namespace(self):
 
290
        self.make_linear_branch('branch1')
 
291
        self.make_linear_branch('branch2')
 
292
        # There is no guarantee that a path exist between two arbitrary
 
293
        # revisions.
 
294
        self.run_bzr("log -r revno:2:branch1..revno:3:branch2", retcode=3)
 
295
 
 
296
    def test_log_revno_n_path_correct_order(self):
 
297
        self.make_linear_branch('branch2')
 
298
        self.assertLogRevnos(['-rrevno:1:branch2..revno:3:branch2'],
 
299
                             ['3', '2','1'])
185
300
 
186
301
    def test_log_revno_n_path(self):
187
 
        self.make_linear_branch('branch1')
188
302
        self.make_linear_branch('branch2')
189
 
        # Swapped revisions
190
 
        self.run_bzr("log -r revno:2:branch1..revno:3:branch2", retcode=3)[0]
191
 
        # Correct order
192
 
        log = self.run_bzr("log -r revno:1:branch2..revno:3:branch2")[0]
193
 
        full_log = self.run_bzr(['log'], working_dir='branch2')[0]
194
 
        self.assertEqualDiff(full_log, log)
195
 
        log = self.run_bzr("log -r revno:1:branch2")[0]
196
 
        self.assertTrue('revno: 1\n' in log)
197
 
        self.assertTrue('revno: 2\n' not in log)
198
 
        self.assertTrue('branch nick: branch2\n' in log)
199
 
        self.assertTrue('branch nick: branch1\n' not in log)
 
303
        self.assertLogRevnos(['-rrevno:1:branch2'],
 
304
                             ['1'])
 
305
        rev_props = self.log_catcher.revisions[0].rev.properties
 
306
        self.assertEqual('branch2', rev_props['branch-nick'])
 
307
 
 
308
 
 
309
class TestLogErrors(TestLog):
 
310
 
 
311
    def test_log_zero_revspec(self):
 
312
        self.make_minimal_branch()
 
313
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
 
314
                           ['log', '-r0'])
 
315
 
 
316
    def test_log_zero_begin_revspec(self):
 
317
        self.make_linear_branch()
 
318
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
 
319
                           ['log', '-r0..2'])
 
320
 
 
321
    def test_log_zero_end_revspec(self):
 
322
        self.make_linear_branch()
 
323
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
 
324
                           ['log', '-r-2..0'])
200
325
 
201
326
    def test_log_nonexistent_revno(self):
202
327
        self.make_minimal_branch()
203
 
        (out, err) = self.run_bzr_error(
204
 
            ["bzr: ERROR: Requested revision: '1234' "
205
 
             "does not exist in branch:"],
206
 
            ['log', '-r1234'])
 
328
        self.run_bzr_error(["bzr: ERROR: Requested revision: '1234' "
 
329
                            "does not exist in branch:"],
 
330
                           ['log', '-r1234'])
207
331
 
208
332
    def test_log_nonexistent_dotted_revno(self):
209
333
        self.make_minimal_branch()
210
 
        (out, err) = self.run_bzr_error(
211
 
            ["bzr: ERROR: Requested revision: '123.123' "
212
 
             "does not exist in branch:"],
213
 
            ['log',  '-r123.123'])
214
 
 
215
 
    def test_log_change_revno(self):
216
 
        self.make_linear_branch()
217
 
        expected_log = self.run_bzr("log -r 1")[0]
218
 
        log = self.run_bzr("log -c 1")[0]
219
 
        self.assertEqualDiff(expected_log, log)
 
334
        self.run_bzr_error(["bzr: ERROR: Requested revision: '123.123' "
 
335
                            "does not exist in branch:"],
 
336
                           ['log',  '-r123.123'])
220
337
 
221
338
    def test_log_change_nonexistent_revno(self):
222
339
        self.make_minimal_branch()
223
 
        (out, err) = self.run_bzr_error(
224
 
            ["bzr: ERROR: Requested revision: '1234' "
225
 
             "does not exist in branch:"],
226
 
            ['log',  '-c1234'])
 
340
        self.run_bzr_error(["bzr: ERROR: Requested revision: '1234' "
 
341
                            "does not exist in branch:"],
 
342
                           ['log',  '-c1234'])
227
343
 
228
344
    def test_log_change_nonexistent_dotted_revno(self):
229
345
        self.make_minimal_branch()
230
 
        (out, err) = self.run_bzr_error(
231
 
            ["bzr: ERROR: Requested revision: '123.123' "
232
 
             "does not exist in branch:"],
233
 
            ['log', '-c123.123'])
 
346
        self.run_bzr_error(["bzr: ERROR: Requested revision: '123.123' "
 
347
                            "does not exist in branch:"],
 
348
                           ['log', '-c123.123'])
234
349
 
235
350
    def test_log_change_single_revno_only(self):
236
351
        self.make_minimal_branch()
252
367
                              'Path unknown at end or start of revision range: '
253
368
                              'does-not-exist')
254
369
 
 
370
    def test_log_reversed_revspecs(self):
 
371
        self.make_linear_branch()
 
372
        self.run_bzr_error(('bzr: ERROR: Start revision must be older than '
 
373
                            'the end revision.\n',),
 
374
                           ['log', '-r3..1'])
 
375
 
 
376
    def test_log_reversed_dotted_revspecs(self):
 
377
        self.make_merged_branch()
 
378
        self.run_bzr_error(('bzr: ERROR: Start revision not found in '
 
379
                            'left-hand history of end revision.\n',),
 
380
                           "log -r 1.1.1..1")
 
381
 
 
382
    def test_log_bad_message_re(self):
 
383
        """Bad --message argument gives a sensible message
 
384
 
 
385
        See https://bugs.launchpad.net/bzr/+bug/251352
 
386
        """
 
387
        self.make_minimal_branch()
 
388
        out, err = self.run_bzr(['log', '-m', '*'], retcode=3)
 
389
        self.assertContainsRe(err, "ERROR.*Invalid pattern.*nothing to repeat")
 
390
        self.assertNotContainsRe(err, "Unprintable exception")
 
391
        self.assertEqual(out, '')
 
392
 
 
393
    def test_log_unsupported_timezone(self):
 
394
        self.make_linear_branch()
 
395
        self.run_bzr_error(['bzr: ERROR: Unsupported timezone format "foo", '
 
396
                            'options are "utc", "original", "local".'],
 
397
                           ['log', '--timezone', 'foo'])
 
398
 
 
399
    def test_log_exclude_ancestry_no_range(self):
 
400
        self.make_linear_branch()
 
401
        self.run_bzr_error(['bzr: ERROR: --exclude-common-ancestry'
 
402
                            ' requires -r with two revisions'],
 
403
                           ['log', '--exclude-common-ancestry'])
 
404
 
 
405
    def test_log_exclude_ancestry_single_revision(self):
 
406
        self.make_merged_branch()
 
407
        self.run_bzr_error(['bzr: ERROR: --exclude-common-ancestry'
 
408
                            ' requires two different revisions'],
 
409
                           ['log', '--exclude-common-ancestry',
 
410
                            '-r1.1.1..1.1.1'])
 
411
 
 
412
class TestLogTags(TestLog):
 
413
 
255
414
    def test_log_with_tags(self):
256
415
        tree = self.make_linear_branch(format='dirstate-tags')
257
416
        branch = tree.branch
282
441
        log = self.run_bzr("log -n0 -r3.1.1", working_dir='branch2')[0]
283
442
        self.assertContainsRe(log, r'tags: tag1')
284
443
 
285
 
    def test_log_limit(self):
286
 
        tree = self.make_branch_and_tree('.')
287
 
        # We want more commits than our batch size starts at
288
 
        for pos in range(10):
289
 
            tree.commit("%s" % pos)
290
 
        log = self.run_bzr("log --limit 2")[0]
291
 
        self.assertNotContainsRe(log, r'revno: 1\n')
292
 
        self.assertNotContainsRe(log, r'revno: 2\n')
293
 
        self.assertNotContainsRe(log, r'revno: 3\n')
294
 
        self.assertNotContainsRe(log, r'revno: 4\n')
295
 
        self.assertNotContainsRe(log, r'revno: 5\n')
296
 
        self.assertNotContainsRe(log, r'revno: 6\n')
297
 
        self.assertNotContainsRe(log, r'revno: 7\n')
298
 
        self.assertNotContainsRe(log, r'revno: 8\n')
299
 
        self.assertContainsRe(log, r'revno: 9\n')
300
 
        self.assertContainsRe(log, r'revno: 10\n')
301
 
 
302
 
    def test_log_limit_short(self):
303
 
        self.make_linear_branch()
304
 
        log = self.run_bzr("log -l 2")[0]
305
 
        self.assertNotContainsRe(log, r'revno: 1\n')
306
 
        self.assertContainsRe(log, r'revno: 2\n')
307
 
        self.assertContainsRe(log, r'revno: 3\n')
308
 
 
309
 
    def test_log_bad_message_re(self):
310
 
        """Bad --message argument gives a sensible message
311
 
        
312
 
        See https://bugs.launchpad.net/bzr/+bug/251352
313
 
        """
314
 
        self.make_minimal_branch()
315
 
        out, err = self.run_bzr(['log', '-m', '*'], retcode=3)
316
 
        self.assertEqual("bzr: ERROR: Invalid regular expression"
317
 
            " in log message filter"
318
 
            ": '*'"
319
 
            ": nothing to repeat\n", err)
320
 
        self.assertEqual('', out)
321
 
 
322
 
 
323
 
class TestLogTimeZone(TestLog):
324
 
 
325
 
    def test_log_unsupported_timezone(self):
326
 
        self.make_linear_branch()
327
 
        self.run_bzr_error(['bzr: ERROR: Unsupported timezone format "foo", '
328
 
                            'options are "utc", "original", "local".'],
329
 
                           ['log', '--timezone', 'foo'])
330
 
 
331
444
 
332
445
class TestLogVerbose(TestLog):
333
446
 
364
477
        self.assertUseLongDeltaFormat(['log', '--long', '-vv'])
365
478
 
366
479
 
367
 
class TestLogMerges(TestLog):
 
480
class TestLogMerges(TestLogWithLogCatcher):
368
481
 
369
482
    def setUp(self):
370
483
        super(TestLogMerges, self).setUp()
372
485
 
373
486
    def make_branches_with_merges(self):
374
487
        level0 = self.make_branch_and_tree('level0')
375
 
        level0.commit(message='in branch level0', **self.commit_options())
376
 
 
 
488
        self.wt_commit(level0, 'in branch level0')
377
489
        level1 = level0.bzrdir.sprout('level1').open_workingtree()
378
 
        level1.commit(message='in branch level1', **self.commit_options())
379
 
 
 
490
        self.wt_commit(level1, 'in branch level1')
380
491
        level2 = level1.bzrdir.sprout('level2').open_workingtree()
381
 
        level2.commit(message='in branch level2', **self.commit_options())
382
 
 
 
492
        self.wt_commit(level2, 'in branch level2')
383
493
        level1.merge_from_branch(level2.branch)
384
 
        level1.commit(message='merge branch level2', **self.commit_options())
385
 
 
 
494
        self.wt_commit(level1, 'merge branch level2')
386
495
        level0.merge_from_branch(level1.branch)
387
 
        level0.commit(message='merge branch level1', **self.commit_options())
 
496
        self.wt_commit(level0, 'merge branch level1')
388
497
 
389
498
    def test_merges_are_indented_by_level(self):
390
 
        expected = """\
391
 
------------------------------------------------------------
392
 
revno: 2 [merge]
393
 
committer: Lorem Ipsum <test@example.com>
394
 
branch nick: level0
395
 
timestamp: Just now
396
 
message:
397
 
  merge branch level1
398
 
    ------------------------------------------------------------
399
 
    revno: 1.1.2 [merge]
400
 
    committer: Lorem Ipsum <test@example.com>
401
 
    branch nick: level1
402
 
    timestamp: Just now
403
 
    message:
404
 
      merge branch level2
405
 
        ------------------------------------------------------------
406
 
        revno: 1.2.1
407
 
        committer: Lorem Ipsum <test@example.com>
408
 
        branch nick: level2
409
 
        timestamp: Just now
410
 
        message:
411
 
          in branch level2
412
 
    ------------------------------------------------------------
413
 
    revno: 1.1.1
414
 
    committer: Lorem Ipsum <test@example.com>
415
 
    branch nick: level1
416
 
    timestamp: Just now
417
 
    message:
418
 
      in branch level1
419
 
------------------------------------------------------------
420
 
revno: 1
421
 
committer: Lorem Ipsum <test@example.com>
422
 
branch nick: level0
423
 
timestamp: Just now
424
 
message:
425
 
  in branch level0
426
 
"""
427
 
        self.check_log(expected, ['-n0'])
 
499
        self.run_bzr(['log', '-n0'], working_dir='level0')
 
500
        revnos_and_depth = [(r.revno, r.merge_depth)
 
501
                            for r in self.get_captured_revisions()]
 
502
        self.assertEqual([('2', 0), ('1.1.2', 1), ('1.2.1', 2), ('1.1.1', 1),
 
503
                          ('1', 0)],
 
504
                         [(r.revno, r.merge_depth)
 
505
                            for r in self.get_captured_revisions()])
428
506
 
429
507
    def test_force_merge_revisions_off(self):
430
 
        expected = """\
431
 
------------------------------------------------------------
432
 
revno: 2 [merge]
433
 
committer: Lorem Ipsum <test@example.com>
434
 
branch nick: level0
435
 
timestamp: Just now
436
 
message:
437
 
  merge branch level1
438
 
------------------------------------------------------------
439
 
revno: 1
440
 
committer: Lorem Ipsum <test@example.com>
441
 
branch nick: level0
442
 
timestamp: Just now
443
 
message:
444
 
  in branch level0
445
 
"""
446
 
        self.check_log(expected, ['--long', '-n1'])
 
508
        self.assertLogRevnos(['-n1'], ['2', '1'], working_dir='level0')
447
509
 
448
510
    def test_force_merge_revisions_on(self):
449
 
        expected = """\
450
 
    2 Lorem Ipsum\t2005-11-22 [merge]
451
 
      merge branch level1
452
 
 
453
 
          1.1.2 Lorem Ipsum\t2005-11-22 [merge]
454
 
                merge branch level2
455
 
 
456
 
              1.2.1 Lorem Ipsum\t2005-11-22
457
 
                    in branch level2
458
 
 
459
 
          1.1.1 Lorem Ipsum\t2005-11-22
460
 
                in branch level1
461
 
 
462
 
    1 Lorem Ipsum\t2005-11-22
463
 
      in branch level0
464
 
 
465
 
"""
466
 
        self.check_log(expected, ['--short', '-n0'])
 
511
        self.assertLogRevnos(['-n0'], ['2', '1.1.2', '1.2.1', '1.1.1', '1'],
 
512
                             working_dir='level0')
467
513
 
468
514
    def test_include_merges(self):
469
515
        # Confirm --include-merges gives the same output as -n0
 
516
        self.assertLogRevnos(['--include-merges'],
 
517
                             ['2', '1.1.2', '1.2.1', '1.1.1', '1'],
 
518
                             working_dir='level0')
 
519
        self.assertLogRevnos(['--include-merges'],
 
520
                             ['2', '1.1.2', '1.2.1', '1.1.1', '1'],
 
521
                             working_dir='level0')
470
522
        out_im, err_im = self.run_bzr('log --include-merges',
471
523
                                      working_dir='level0')
472
524
        out_n0, err_n0 = self.run_bzr('log -n0', working_dir='level0')
475
527
        self.assertEqual(out_im, out_n0)
476
528
 
477
529
    def test_force_merge_revisions_N(self):
478
 
        expected = """\
479
 
    2 Lorem Ipsum\t2005-11-22 [merge]
480
 
      merge branch level1
481
 
 
482
 
          1.1.2 Lorem Ipsum\t2005-11-22 [merge]
483
 
                merge branch level2
484
 
 
485
 
          1.1.1 Lorem Ipsum\t2005-11-22
486
 
                in branch level1
487
 
 
488
 
    1 Lorem Ipsum\t2005-11-22
489
 
      in branch level0
490
 
 
491
 
"""
492
 
        self.check_log(expected, ['--short', '-n2'])
 
530
        self.assertLogRevnos(['-n2'],
 
531
                             ['2', '1.1.2', '1.1.1', '1'],
 
532
                             working_dir='level0')
493
533
 
494
534
    def test_merges_single_merge_rev(self):
495
 
        expected = """\
496
 
------------------------------------------------------------
497
 
revno: 1.1.2 [merge]
498
 
committer: Lorem Ipsum <test@example.com>
499
 
branch nick: level1
500
 
timestamp: Just now
501
 
message:
502
 
  merge branch level2
503
 
    ------------------------------------------------------------
504
 
    revno: 1.2.1
505
 
    committer: Lorem Ipsum <test@example.com>
506
 
    branch nick: level2
507
 
    timestamp: Just now
508
 
    message:
509
 
      in branch level2
510
 
"""
511
 
        self.check_log(expected, ['-n0', '-r1.1.2'])
 
535
        self.assertLogRevnosAndDepths(['-n0', '-r1.1.2'],
 
536
                                      [('1.1.2', 0), ('1.2.1', 1)],
 
537
                                      working_dir='level0')
512
538
 
513
539
    def test_merges_partial_range(self):
514
 
        expected = """\
515
 
------------------------------------------------------------
516
 
revno: 1.1.2 [merge]
517
 
committer: Lorem Ipsum <test@example.com>
518
 
branch nick: level1
519
 
timestamp: Just now
520
 
message:
521
 
  merge branch level2
522
 
    ------------------------------------------------------------
523
 
    revno: 1.2.1
524
 
    committer: Lorem Ipsum <test@example.com>
525
 
    branch nick: level2
526
 
    timestamp: Just now
527
 
    message:
528
 
      in branch level2
529
 
------------------------------------------------------------
530
 
revno: 1.1.1
531
 
committer: Lorem Ipsum <test@example.com>
532
 
branch nick: level1
533
 
timestamp: Just now
534
 
message:
535
 
  in branch level1
536
 
"""
537
 
        self.check_log(expected, ['-n0', '-r1.1.1..1.1.2'])
 
540
        self.assertLogRevnosAndDepths(
 
541
                ['-n0', '-r1.1.1..1.1.2'],
 
542
                [('1.1.2', 0), ('1.2.1', 1), ('1.1.1', 0)],
 
543
                working_dir='level0')
538
544
 
539
545
    def test_merges_partial_range_ignore_before_lower_bound(self):
540
546
        """Dont show revisions before the lower bound's merged revs"""
541
 
        expected = """\
542
 
    2 Lorem Ipsum\t2005-11-22 [merge]
543
 
      merge branch level1
544
 
 
545
 
          1.1.2 Lorem Ipsum\t2005-11-22 [merge]
546
 
                merge branch level2
547
 
 
548
 
              1.2.1 Lorem Ipsum\t2005-11-22
549
 
                    in branch level2
550
 
 
551
 
"""
552
 
        self.check_log(expected, ['--short', '-n0', '-r1.1.2..2'])
553
 
 
554
 
 
555
 
class TestLogDiff(TestLog):
 
547
        self.assertLogRevnosAndDepths(
 
548
                ['-n0', '-r1.1.2..2'],
 
549
                [('2', 0), ('1.1.2', 1), ('1.2.1', 2)],
 
550
                working_dir='level0')
 
551
 
 
552
 
 
553
class TestLogDiff(TestLogWithLogCatcher):
 
554
 
 
555
    # FIXME: We need specific tests for each LogFormatter about how the diffs
 
556
    # are displayed: --long indent them by depth, --short use a fixed
 
557
    # indent and --line does't display them. -- vila 10019
556
558
 
557
559
    def setUp(self):
558
560
        super(TestLogDiff, self).setUp()
563
565
        self.build_tree(['level0/file1', 'level0/file2'])
564
566
        level0.add('file1')
565
567
        level0.add('file2')
566
 
        level0.commit(message='in branch level0', **self.commit_options())
 
568
        self.wt_commit(level0, 'in branch level0')
567
569
 
568
570
        level1 = level0.bzrdir.sprout('level1').open_workingtree()
569
571
        self.build_tree_contents([('level1/file2', 'hello\n')])
570
 
        level1.commit(message='in branch level1', **self.commit_options())
 
572
        self.wt_commit(level1, 'in branch level1')
571
573
        level0.merge_from_branch(level1.branch)
572
 
        level0.commit(message='merge branch level1', **self.commit_options())
 
574
        self.wt_commit(level0, 'merge branch level1')
573
575
 
574
 
    def test_log_show_diff_long_with_merges(self):
575
 
        out,err = self.run_bzr('log -p -n0')
576
 
        self.assertEqual('', err)
577
 
        log = test_log.normalize_log(out)
578
 
        expected = """\
579
 
------------------------------------------------------------
580
 
revno: 2 [merge]
581
 
committer: Lorem Ipsum <test@example.com>
582
 
branch nick: level0
583
 
timestamp: Just now
584
 
message:
585
 
  merge branch level1
586
 
diff:
587
 
=== modified file 'file2'
588
 
--- file2\t2005-11-22 00:00:01 +0000
589
 
+++ file2\t2005-11-22 00:00:02 +0000
590
 
@@ -1,1 +1,1 @@
591
 
-contents of level0/file2
592
 
+hello
593
 
    ------------------------------------------------------------
594
 
    revno: 1.1.1
595
 
    committer: Lorem Ipsum <test@example.com>
596
 
    branch nick: level1
597
 
    timestamp: Just now
598
 
    message:
599
 
      in branch level1
600
 
    diff:
601
 
    === modified file 'file2'
602
 
    --- file2\t2005-11-22 00:00:01 +0000
603
 
    +++ file2\t2005-11-22 00:00:02 +0000
604
 
    @@ -1,1 +1,1 @@
605
 
    -contents of level0/file2
606
 
    +hello
607
 
------------------------------------------------------------
608
 
revno: 1
609
 
committer: Lorem Ipsum <test@example.com>
610
 
branch nick: level0
611
 
timestamp: Just now
612
 
message:
613
 
  in branch level0
614
 
diff:
615
 
=== added file 'file1'
 
576
    def _diff_file1_revno1(self):
 
577
        return """=== added file 'file1'
616
578
--- file1\t1970-01-01 00:00:00 +0000
617
 
+++ file1\t2005-11-22 00:00:01 +0000
 
579
+++ file1\t2005-11-22 00:00:00 +0000
618
580
@@ -0,0 +1,1 @@
619
581
+contents of level0/file1
620
582
 
621
 
=== added file 'file2'
 
583
"""
 
584
 
 
585
    def _diff_file2_revno2(self):
 
586
        return """=== modified file 'file2'
 
587
--- file2\t2005-11-22 00:00:00 +0000
 
588
+++ file2\t2005-11-22 00:00:01 +0000
 
589
@@ -1,1 +1,1 @@
 
590
-contents of level0/file2
 
591
+hello
 
592
 
 
593
"""
 
594
 
 
595
    def _diff_file2_revno1_1_1(self):
 
596
        return """=== modified file 'file2'
 
597
--- file2\t2005-11-22 00:00:00 +0000
 
598
+++ file2\t2005-11-22 00:00:01 +0000
 
599
@@ -1,1 +1,1 @@
 
600
-contents of level0/file2
 
601
+hello
 
602
 
 
603
"""
 
604
 
 
605
    def _diff_file2_revno1(self):
 
606
        return """=== added file 'file2'
622
607
--- file2\t1970-01-01 00:00:00 +0000
623
 
+++ file2\t2005-11-22 00:00:01 +0000
 
608
+++ file2\t2005-11-22 00:00:00 +0000
624
609
@@ -0,0 +1,1 @@
625
610
+contents of level0/file2
626
 
"""
627
 
        self.check_log(expected, ['-p', '-n0'])
628
 
 
629
 
    def test_log_show_diff_short(self):
630
 
        expected = """\
631
 
    2 Lorem Ipsum\t2005-11-22 [merge]
632
 
      merge branch level1
633
 
      === modified file 'file2'
634
 
      --- file2\t2005-11-22 00:00:01 +0000
635
 
      +++ file2\t2005-11-22 00:00:02 +0000
636
 
      @@ -1,1 +1,1 @@
637
 
      -contents of level0/file2
638
 
      +hello
639
 
 
640
 
    1 Lorem Ipsum\t2005-11-22
641
 
      in branch level0
642
 
      === added file 'file1'
643
 
      --- file1\t1970-01-01 00:00:00 +0000
644
 
      +++ file1\t2005-11-22 00:00:01 +0000
645
 
      @@ -0,0 +1,1 @@
646
 
      +contents of level0/file1
647
 
\x20\x20\x20\x20\x20\x20
648
 
      === added file 'file2'
649
 
      --- file2\t1970-01-01 00:00:00 +0000
650
 
      +++ file2\t2005-11-22 00:00:01 +0000
651
 
      @@ -0,0 +1,1 @@
652
 
      +contents of level0/file2
653
 
 
654
 
Use --include-merges or -n0 to see merged revisions.
655
 
"""
656
 
        self.check_log(expected, ['-p', '--short'])
657
 
 
658
 
    def test_log_show_diff_line(self):
659
 
        # Not supported by this formatter so expect plain output
660
 
        expected = """\
661
 
2: Lorem Ipsum 2005-11-22 [merge] merge branch level1
662
 
1: Lorem Ipsum 2005-11-22 in branch level0
663
 
"""
664
 
        self.check_log(expected, ['-p', '--line'])
665
 
 
666
 
    def test_log_show_diff_file1(self):
667
 
        """Only the diffs for the given file are to be shown"""
668
 
        expected = """\
669
 
    1 Lorem Ipsum\t2005-11-22
670
 
      in branch level0
671
 
      === added file 'file1'
672
 
      --- file1\t1970-01-01 00:00:00 +0000
673
 
      +++ file1\t2005-11-22 00:00:01 +0000
674
 
      @@ -0,0 +1,1 @@
675
 
      +contents of level0/file1
676
 
 
677
 
"""
678
 
        self.check_log(expected, ['-p', '--short', 'file1'])
679
 
 
680
 
    def test_log_show_diff_file2(self):
681
 
        """Only the diffs for the given file are to be shown"""
682
 
        expected = """\
683
 
    2 Lorem Ipsum\t2005-11-22 [merge]
684
 
      merge branch level1
685
 
      === modified file 'file2'
686
 
      --- file2\t2005-11-22 00:00:01 +0000
687
 
      +++ file2\t2005-11-22 00:00:02 +0000
688
 
      @@ -1,1 +1,1 @@
689
 
      -contents of level0/file2
690
 
      +hello
691
 
 
692
 
    1 Lorem Ipsum\t2005-11-22
693
 
      in branch level0
694
 
      === added file 'file2'
695
 
      --- file2\t1970-01-01 00:00:00 +0000
696
 
      +++ file2\t2005-11-22 00:00:01 +0000
697
 
      @@ -0,0 +1,1 @@
698
 
      +contents of level0/file2
699
 
 
700
 
Use --include-merges or -n0 to see merged revisions.
701
 
"""
702
 
        self.check_log(expected, ['-p', '--short', 'file2'])
 
611
 
 
612
"""
 
613
 
 
614
    def assertLogRevnosAndDiff(self, args, expected,
 
615
                            working_dir='.'):
 
616
        self.run_bzr(['log', '-p'] + args, working_dir=working_dir)
 
617
        expected_revnos_and_depths = [
 
618
            (revno, depth) for revno, depth, diff in expected]
 
619
        # Check the revnos and depths first to make debugging easier
 
620
        self.assertEqual(expected_revnos_and_depths,
 
621
                         [(r.revno, r.merge_depth)
 
622
                           for r in self.get_captured_revisions()])
 
623
        # Now check the diffs, adding the revno  in case of failure
 
624
        fmt = 'In revno %s\n%s'
 
625
        for expected_rev, actual_rev in izip(expected,
 
626
                                             self.get_captured_revisions()):
 
627
            revno, depth, expected_diff = expected_rev
 
628
            actual_diff = actual_rev.diff
 
629
            self.assertEqualDiff(fmt % (revno, expected_diff),
 
630
                                 fmt % (revno, actual_diff))
 
631
 
 
632
    def test_log_diff_with_merges(self):
 
633
        self.assertLogRevnosAndDiff(
 
634
            ['-n0'],
 
635
            [('2', 0, self._diff_file2_revno2()),
 
636
             ('1.1.1', 1, self._diff_file2_revno1_1_1()),
 
637
             ('1', 0, self._diff_file1_revno1()
 
638
              + self._diff_file2_revno1())],
 
639
            working_dir='level0')
 
640
 
 
641
 
 
642
    def test_log_diff_file1(self):
 
643
        self.assertLogRevnosAndDiff(['-n0', 'file1'],
 
644
                                    [('1', 0, self._diff_file1_revno1())],
 
645
                                    working_dir='level0')
 
646
 
 
647
    def test_log_diff_file2(self):
 
648
        self.assertLogRevnosAndDiff(['-n1', 'file2'],
 
649
                                    [('2', 0, self._diff_file2_revno2()),
 
650
                                     ('1', 0, self._diff_file2_revno1())],
 
651
                                    working_dir='level0')
703
652
 
704
653
 
705
654
class TestLogUnicodeDiff(TestLog):
748
697
 
749
698
    def setUp(self):
750
699
        super(TestLogEncodings, self).setUp()
751
 
        self.user_encoding = osutils._cached_user_encoding
752
 
        def restore():
753
 
            osutils._cached_user_encoding = self.user_encoding
754
 
        self.addCleanup(restore)
 
700
        self.overrideAttr(osutils, '_cached_user_encoding')
755
701
 
756
702
    def create_branch(self):
757
703
        bzr = self.run_bzr
758
704
        bzr('init')
759
 
        open('a', 'wb').write('some stuff\n')
 
705
        self.build_tree_contents([('a', 'some stuff\n')])
760
706
        bzr('add a')
761
707
        bzr(['commit', '-m', self._message])
762
708
 
825
771
        self.assertEquals(-1, stdout.find(test_in_cp1251))
826
772
 
827
773
 
828
 
class TestLogFile(tests.TestCaseWithTransport):
 
774
class TestLogFile(TestLogWithLogCatcher):
829
775
 
830
776
    def test_log_local_branch_file(self):
831
777
        """We should be able to log files in local treeless branches"""
860
806
            tree.commit('remove file1')
861
807
        os.chdir('parent')
862
808
 
863
 
    def test_log_file(self):
864
 
        """The log for a particular file should only list revs for that file"""
865
 
        self.prepare_tree()
866
 
        log = self.run_bzr('log -n0 file1')[0]
867
 
        self.assertContainsRe(log, 'revno: 1\n')
868
 
        self.assertNotContainsRe(log, 'revno: 2\n')
869
 
        self.assertNotContainsRe(log, 'revno: 3\n')
870
 
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
871
 
        self.assertNotContainsRe(log, 'revno: 4 ')
872
 
        log = self.run_bzr('log -n0 file2')[0]
873
 
        self.assertNotContainsRe(log, 'revno: 1\n')
874
 
        self.assertContainsRe(log, 'revno: 2\n')
875
 
        self.assertNotContainsRe(log, 'revno: 3\n')
876
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
877
 
        self.assertContainsRe(log, 'revno: 4 ')
878
 
        log = self.run_bzr('log -n0 file3')[0]
879
 
        self.assertNotContainsRe(log, 'revno: 1\n')
880
 
        self.assertNotContainsRe(log, 'revno: 2\n')
881
 
        self.assertContainsRe(log, 'revno: 3\n')
882
 
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
883
 
        self.assertNotContainsRe(log, 'revno: 4 ')
884
 
        log = self.run_bzr('log -n0 -r3.1.1 file2')[0]
885
 
        self.assertNotContainsRe(log, 'revno: 1\n')
886
 
        self.assertNotContainsRe(log, 'revno: 2\n')
887
 
        self.assertNotContainsRe(log, 'revno: 3\n')
888
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
889
 
        self.assertNotContainsRe(log, 'revno: 4 ')
890
 
        log = self.run_bzr('log -n0 -r4 file2')[0]
891
 
        self.assertNotContainsRe(log, 'revno: 1\n')
892
 
        self.assertNotContainsRe(log, 'revno: 2\n')
893
 
        self.assertNotContainsRe(log, 'revno: 3\n')
894
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
895
 
        self.assertContainsRe(log, 'revno: 4 ')
896
 
        log = self.run_bzr('log -n0 -r3.. file2')[0]
897
 
        self.assertNotContainsRe(log, 'revno: 1\n')
898
 
        self.assertNotContainsRe(log, 'revno: 2\n')
899
 
        self.assertNotContainsRe(log, 'revno: 3\n')
900
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
901
 
        self.assertContainsRe(log, 'revno: 4 ')
902
 
        log = self.run_bzr('log -n0 -r..3 file2')[0]
903
 
        self.assertNotContainsRe(log, 'revno: 1\n')
904
 
        self.assertContainsRe(log, 'revno: 2\n')
905
 
        self.assertNotContainsRe(log, 'revno: 3\n')
906
 
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
907
 
        self.assertNotContainsRe(log, 'revno: 4 ')
 
809
    # FIXME: It would be good to parametrize the following tests against all
 
810
    # formatters. But the revisions selection is not *currently* part of the
 
811
    # LogFormatter contract, so using LogCatcher is sufficient -- vila 100118
 
812
    def test_log_file1(self):
 
813
        self.prepare_tree()
 
814
        self.assertLogRevnos(['-n0', 'file1'], ['1'])
 
815
 
 
816
    def test_log_file2(self):
 
817
        self.prepare_tree()
 
818
        # file2 full history
 
819
        self.assertLogRevnos(['-n0', 'file2'], ['4', '3.1.1', '2'])
 
820
        # file2 in a merge revision
 
821
        self.assertLogRevnos(['-n0', '-r3.1.1', 'file2'], ['3.1.1'])
 
822
        # file2 in a mainline revision
 
823
        self.assertLogRevnos(['-n0', '-r4', 'file2'], ['4', '3.1.1'])
 
824
        # file2 since a revision
 
825
        self.assertLogRevnos(['-n0', '-r3..', 'file2'], ['4', '3.1.1'])
 
826
        # file2 up to a revision
 
827
        self.assertLogRevnos(['-n0', '-r..3', 'file2'], ['2'])
 
828
 
 
829
    def test_log_file3(self):
 
830
        self.prepare_tree()
 
831
        self.assertLogRevnos(['-n0', 'file3'], ['3'])
908
832
 
909
833
    def test_log_file_historical_missing(self):
910
834
        # Check logging a deleted file gives an error if the
918
842
        # Check logging a deleted file is ok if the file existed
919
843
        # at the end the revision range
920
844
        self.prepare_tree(complex=True)
921
 
        log, err = self.run_bzr('log -n0 -r..4 file2')
922
 
        self.assertEquals('', err)
923
 
        self.assertNotContainsRe(log, 'revno: 1\n')
924
 
        self.assertContainsRe(log, 'revno: 2\n')
925
 
        self.assertNotContainsRe(log, 'revno: 3\n')
926
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
927
 
        self.assertContainsRe(log, 'revno: 4 ')
 
845
        self.assertLogRevnos(['-n0', '-r..4', 'file2'], ['4', '3.1.1', '2'])
928
846
 
929
847
    def test_log_file_historical_start(self):
930
848
        # Check logging a deleted file is ok if the file existed
931
849
        # at the start of the revision range
932
850
        self.prepare_tree(complex=True)
933
 
        log, err = self.run_bzr('log file1')
934
 
        self.assertEquals('', err)
935
 
        self.assertContainsRe(log, 'revno: 1\n')
936
 
        self.assertNotContainsRe(log, 'revno: 2\n')
937
 
        self.assertNotContainsRe(log, 'revno: 3\n')
938
 
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
939
 
        self.assertNotContainsRe(log, 'revno: 4 ')
 
851
        self.assertLogRevnos(['file1'], ['1'])
940
852
 
941
853
    def test_log_file_renamed(self):
942
854
        """File matched against revision range, not current tree."""
948
860
        self.assertContainsRe(err, err_msg)
949
861
 
950
862
        # Check we can see a renamed file if we give the right end revision
951
 
        log, err = self.run_bzr('log -r..4 file3')
952
 
        self.assertEquals('', err)
953
 
        self.assertNotContainsRe(log, 'revno: 1\n')
954
 
        self.assertNotContainsRe(log, 'revno: 2\n')
955
 
        self.assertContainsRe(log, 'revno: 3\n')
956
 
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
957
 
        self.assertNotContainsRe(log, 'revno: 4 ')
958
 
 
959
 
    def test_line_log_file(self):
960
 
        """The line log for a file should only list relevant mainline revs"""
961
 
        # Note: this also implicitly  covers the short logging case.
962
 
        # We test using --line in preference to --short because matching
963
 
        # revnos in the output of --line is more reliable.
964
 
        self.prepare_tree()
965
 
 
966
 
        # full history of file1
967
 
        log = self.run_bzr('log --line file1')[0]
968
 
        self.assertContainsRe(log, '^1:', re.MULTILINE)
969
 
        self.assertNotContainsRe(log, '^2:', re.MULTILINE)
970
 
        self.assertNotContainsRe(log, '^3:', re.MULTILINE)
971
 
        self.assertNotContainsRe(log, '^3.1.1:', re.MULTILINE)
972
 
        self.assertNotContainsRe(log, '^4:', re.MULTILINE)
973
 
 
974
 
        # full history of file2
975
 
        log = self.run_bzr('log --line file2')[0]
976
 
        self.assertNotContainsRe(log, '^1:', re.MULTILINE)
977
 
        self.assertContainsRe(log, '^2:', re.MULTILINE)
978
 
        self.assertNotContainsRe(log, '^3:', re.MULTILINE)
979
 
        self.assertNotContainsRe(log, '^3.1.1:', re.MULTILINE)
980
 
        self.assertContainsRe(log, '^4:', re.MULTILINE)
981
 
 
982
 
        # full history of file3
983
 
        log = self.run_bzr('log --line file3')[0]
984
 
        self.assertNotContainsRe(log, '^1:', re.MULTILINE)
985
 
        self.assertNotContainsRe(log, '^2:', re.MULTILINE)
986
 
        self.assertContainsRe(log, '^3:', re.MULTILINE)
987
 
        self.assertNotContainsRe(log, '^3.1.1:', re.MULTILINE)
988
 
        self.assertNotContainsRe(log, '^4:', re.MULTILINE)
989
 
 
990
 
        # file in a merge revision
991
 
        log = self.run_bzr('log --line -r3.1.1 file2')[0]
992
 
        self.assertNotContainsRe(log, '^1:', re.MULTILINE)
993
 
        self.assertNotContainsRe(log, '^2:', re.MULTILINE)
994
 
        self.assertNotContainsRe(log, '^3:', re.MULTILINE)
995
 
        self.assertContainsRe(log, '^3.1.1:', re.MULTILINE)
996
 
        self.assertNotContainsRe(log, '^4:', re.MULTILINE)
997
 
 
998
 
        # file in a mainline revision
999
 
        log = self.run_bzr('log --line -r4 file2')[0]
1000
 
        self.assertNotContainsRe(log, '^1:', re.MULTILINE)
1001
 
        self.assertNotContainsRe(log, '^2:', re.MULTILINE)
1002
 
        self.assertNotContainsRe(log, '^3:', re.MULTILINE)
1003
 
        self.assertNotContainsRe(log, '^3.1.1:', re.MULTILINE)
1004
 
        self.assertContainsRe(log, '^4:', re.MULTILINE)
1005
 
 
1006
 
        # file since a revision
1007
 
        log = self.run_bzr('log --line -r3.. file2')[0]
1008
 
        self.assertNotContainsRe(log, '^1:', re.MULTILINE)
1009
 
        self.assertNotContainsRe(log, '^2:', re.MULTILINE)
1010
 
        self.assertNotContainsRe(log, '^3:', re.MULTILINE)
1011
 
        self.assertNotContainsRe(log, '^3.1.1:', re.MULTILINE)
1012
 
        self.assertContainsRe(log, '^4:', re.MULTILINE)
1013
 
 
1014
 
        # file up to a revision
1015
 
        log = self.run_bzr('log --line -r..3 file2')[0]
1016
 
        self.assertNotContainsRe(log, '^1:', re.MULTILINE)
1017
 
        self.assertContainsRe(log, '^2:', re.MULTILINE)
1018
 
        self.assertNotContainsRe(log, '^3:', re.MULTILINE)
1019
 
        self.assertNotContainsRe(log, '^3.1.1:', re.MULTILINE)
1020
 
        self.assertNotContainsRe(log, '^4:', re.MULTILINE)
1021
 
 
1022
 
 
1023
 
class TestLogMultiple(tests.TestCaseWithTransport):
 
863
        self.assertLogRevnos(['-r..4', 'file3'], ['3'])
 
864
 
 
865
 
 
866
class TestLogMultiple(TestLogWithLogCatcher):
1024
867
 
1025
868
    def prepare_tree(self):
1026
869
        tree = self.make_branch_and_tree('parent')
1049
892
        tree.commit(message='merge child branch')
1050
893
        os.chdir('parent')
1051
894
 
1052
 
    def assertRevnos(self, paths_str, expected_revnos):
1053
 
        # confirm the revision numbers in log --line output are those expected
1054
 
        out, err = self.run_bzr('log --line -n0 %s' % (paths_str,))
1055
 
        self.assertEqual('', err)
1056
 
        revnos = [s.split(':', 1)[0].lstrip() for s in out.splitlines()]
1057
 
        self.assertEqual(expected_revnos, revnos)
1058
 
 
1059
895
    def test_log_files(self):
1060
896
        """The log for multiple file should only list revs for those files"""
1061
897
        self.prepare_tree()
1062
 
        self.assertRevnos('file1 file2 dir1/dir2/file3',
1063
 
            ['6', '5.1.1', '3', '2', '1'])
 
898
        self.assertLogRevnos(['file1', 'file2', 'dir1/dir2/file3'],
 
899
                             ['6', '5.1.1', '3', '2', '1'])
1064
900
 
1065
901
    def test_log_directory(self):
1066
902
        """The log for a directory should show all nested files."""
1067
903
        self.prepare_tree()
1068
 
        self.assertRevnos('dir1', ['5', '3'])
 
904
        self.assertLogRevnos(['dir1'], ['5', '3'])
1069
905
 
1070
906
    def test_log_nested_directory(self):
1071
907
        """The log for a directory should show all nested files."""
1072
908
        self.prepare_tree()
1073
 
        self.assertRevnos('dir1/dir2', ['3'])
 
909
        self.assertLogRevnos(['dir1/dir2'], ['3'])
1074
910
 
1075
911
    def test_log_in_nested_directory(self):
1076
912
        """The log for a directory should show all nested files."""
1077
913
        self.prepare_tree()
1078
914
        os.chdir("dir1")
1079
 
        self.assertRevnos('.', ['5', '3'])
 
915
        self.assertLogRevnos(['.'], ['5', '3'])
1080
916
 
1081
917
    def test_log_files_and_directories(self):
1082
918
        """Logging files and directories together should be fine."""
1083
919
        self.prepare_tree()
1084
 
        self.assertRevnos('file4 dir1/dir2', ['4', '3'])
 
920
        self.assertLogRevnos(['file4', 'dir1/dir2'], ['4', '3'])
1085
921
 
1086
922
    def test_log_files_and_dirs_in_nested_directory(self):
1087
923
        """The log for a directory should show all nested files."""
1088
924
        self.prepare_tree()
1089
925
        os.chdir("dir1")
1090
 
        self.assertRevnos('dir2 file5', ['5', '3'])
 
926
        self.assertLogRevnos(['dir2', 'file5'], ['5', '3'])