← 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-11-11 08:45:19 UTC
  • mfrom: (4597.9.22 reports-conflict-resolved)
  • Revision ID: pqm@pqm.ubuntu.com-20101111084519-bmk1zmblp7kex41a
(vila) More feedback about the conflicts just resolved and the remaining
 ones. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_log.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
# -*- coding: utf-8 -*-
 
1
# Copyright (C) 2006-2010 Canonical Ltd
3
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
13
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
 
19
18
"""Black-box tests for bzr log."""
20
19
 
 
20
from itertools import izip
21
21
import os
22
 
 
23
 
import bzrlib
24
 
from bzrlib.tests.blackbox import ExternalBase
25
 
from bzrlib.tests import TestCaseInTempDir, TestCaseWithTransport
26
 
from bzrlib.tests.test_log import (
27
 
    normalize_log,
28
 
    )
29
 
 
30
 
 
31
 
class TestLog(ExternalBase):
32
 
 
33
 
    def _prepare(self, path='.', format=None):
 
22
import re
 
23
 
 
24
from bzrlib import (
 
25
    branchbuilder,
 
26
    errors,
 
27
    log,
 
28
    osutils,
 
29
    tests,
 
30
    )
 
31
from bzrlib.tests import (
 
32
    script,
 
33
    test_log,
 
34
    )
 
35
 
 
36
 
 
37
class TestLog(tests.TestCaseWithTransport, test_log.TestLogMixin):
 
38
 
 
39
    def make_minimal_branch(self, path='.', format=None):
 
40
        tree = self.make_branch_and_tree(path, format=format)
 
41
        self.build_tree([path + '/hello.txt'])
 
42
        tree.add('hello.txt')
 
43
        tree.commit(message='message1')
 
44
        return tree
 
45
 
 
46
    def make_linear_branch(self, path='.', format=None):
34
47
        tree = self.make_branch_and_tree(path, format=format)
35
48
        self.build_tree(
36
49
            [path + '/hello.txt', path + '/goodbye.txt', path + '/meep.txt'])
40
53
        tree.commit(message='message2')
41
54
        tree.add('meep.txt')
42
55
        tree.commit(message='message3')
43
 
        self.full_log = self.run_bzr(["log", path])[0]
44
 
        return tree
 
56
        return tree
 
57
 
 
58
    def make_merged_branch(self, path='.', format=None):
 
59
        tree = self.make_linear_branch(path, format)
 
60
        tree2 = tree.bzrdir.sprout('tree2',
 
61
            revision_id=tree.branch.get_rev_id(1)).open_workingtree()
 
62
        tree2.commit(message='tree2 message2')
 
63
        tree2.commit(message='tree2 message3')
 
64
        tree.merge_from_branch(tree2.branch)
 
65
        tree.commit(message='merge')
 
66
        return tree
 
67
 
 
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'])
45
109
 
46
110
    def test_log_null_end_revspec(self):
47
 
        self._prepare()
48
 
        self.assertTrue('revno: 1\n' in self.full_log)
49
 
        self.assertTrue('revno: 2\n' in self.full_log)
50
 
        self.assertTrue('revno: 3\n' in self.full_log)
51
 
        self.assertTrue('message:\n  message1\n' in self.full_log)
52
 
        self.assertTrue('message:\n  message2\n' in self.full_log)
53
 
        self.assertTrue('message:\n  message3\n' in self.full_log)
54
 
 
55
 
        log = self.run_bzr("log -r 1..")[0]
56
 
        self.assertEqualDiff(log, self.full_log)
 
111
        self.make_linear_branch()
 
112
        self.assertLogRevnos(['-r1..'], ['3', '2', '1'])
57
113
 
58
114
    def test_log_null_begin_revspec(self):
59
 
        self._prepare()
60
 
        log = self.run_bzr("log -r ..3")[0]
61
 
        self.assertEqualDiff(self.full_log, log)
 
115
        self.make_linear_branch()
 
116
        self.assertLogRevnos(['-r..3'], ['3', '2', '1'])
62
117
 
63
118
    def test_log_null_both_revspecs(self):
64
 
        self._prepare()
65
 
        log = self.run_bzr("log -r ..")[0]
66
 
        self.assertEqualDiff(self.full_log, log)
 
119
        self.make_linear_branch()
 
120
        self.assertLogRevnos(['-r..'], ['3', '2', '1'])
 
121
 
 
122
    def test_log_negative_begin_revspec_full_log(self):
 
123
        self.make_linear_branch()
 
124
        self.assertLogRevnos(['-r-3..'], ['3', '2', '1'])
 
125
 
 
126
    def test_log_negative_both_revspec_full_log(self):
 
127
        self.make_linear_branch()
 
128
        self.assertLogRevnos(['-r-3..-1'], ['3', '2', '1'])
 
129
 
 
130
    def test_log_negative_both_revspec_partial(self):
 
131
        self.make_linear_branch()
 
132
        self.assertLogRevnos(['-r-3..-2'], ['2', '1'])
 
133
 
 
134
    def test_log_negative_begin_revspec(self):
 
135
        self.make_linear_branch()
 
136
        self.assertLogRevnos(['-r-2..'], ['3', '2'])
 
137
 
 
138
    def test_log_positive_revspecs(self):
 
139
        self.make_linear_branch()
 
140
        self.assertLogRevnos(['-r1..3'], ['3', '2', '1'])
 
141
 
 
142
    def test_log_dotted_revspecs(self):
 
143
        self.make_merged_branch()
 
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'])
 
300
 
 
301
    def test_log_revno_n_path(self):
 
302
        self.make_linear_branch('branch2')
 
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):
67
310
 
68
311
    def test_log_zero_revspec(self):
69
 
        self._prepare()
70
 
        self.run_bzr_error('bzr: ERROR: Logging revision 0 is invalid.',
 
312
        self.make_minimal_branch()
 
313
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
71
314
                           ['log', '-r0'])
72
315
 
73
316
    def test_log_zero_begin_revspec(self):
74
 
        self._prepare()
75
 
        self.run_bzr_error('bzr: ERROR: Logging revision 0 is invalid.',
 
317
        self.make_linear_branch()
 
318
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
76
319
                           ['log', '-r0..2'])
77
320
 
78
321
    def test_log_zero_end_revspec(self):
79
 
        self._prepare()
80
 
        self.run_bzr_error('bzr: ERROR: Logging revision 0 is invalid.',
 
322
        self.make_linear_branch()
 
323
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
81
324
                           ['log', '-r-2..0'])
82
325
 
83
 
    def test_log_unsupported_timezone(self):
84
 
        self._prepare()
85
 
        self.run_bzr_error('bzr: ERROR: Unsupported timezone format "foo", '
86
 
                           'options are "utc", "original", "local".',
87
 
                           ['log', '--timezone', 'foo'])
88
 
 
89
 
    def test_log_negative_begin_revspec_full_log(self):
90
 
        self._prepare()
91
 
        log = self.run_bzr("log -r -3..")[0]
92
 
        self.assertEqualDiff(self.full_log, log)
93
 
 
94
 
    def test_log_negative_both_revspec_full_log(self):
95
 
        self._prepare()
96
 
        log = self.run_bzr("log -r -3..-1")[0]
97
 
        self.assertEqualDiff(self.full_log, log)
98
 
 
99
 
    def test_log_negative_both_revspec_partial(self):
100
 
        self._prepare()
101
 
        log = self.run_bzr("log -r -3..-2")[0]
102
 
        self.assertTrue('revno: 1\n' in log)
103
 
        self.assertTrue('revno: 2\n' in log)
104
 
        self.assertTrue('revno: 3\n' not in log)
105
 
 
106
 
    def test_log_negative_begin_revspec(self):
107
 
        self._prepare()
108
 
        log = self.run_bzr("log -r -2..")[0]
109
 
        self.assertTrue('revno: 1\n' not in log)
110
 
        self.assertTrue('revno: 2\n' in log)
111
 
        self.assertTrue('revno: 3\n' in log)
112
 
 
113
 
    def test_log_positive_revspecs(self):
114
 
        self._prepare()
115
 
        log = self.run_bzr("log -r 1..3")[0]
116
 
        self.assertEqualDiff(self.full_log, log)
 
326
    def test_log_nonexistent_revno(self):
 
327
        self.make_minimal_branch()
 
328
        self.run_bzr_error(["bzr: ERROR: Requested revision: '1234' "
 
329
                            "does not exist in branch:"],
 
330
                           ['log', '-r1234'])
 
331
 
 
332
    def test_log_nonexistent_dotted_revno(self):
 
333
        self.make_minimal_branch()
 
334
        self.run_bzr_error(["bzr: ERROR: Requested revision: '123.123' "
 
335
                            "does not exist in branch:"],
 
336
                           ['log',  '-r123.123'])
 
337
 
 
338
    def test_log_change_nonexistent_revno(self):
 
339
        self.make_minimal_branch()
 
340
        self.run_bzr_error(["bzr: ERROR: Requested revision: '1234' "
 
341
                            "does not exist in branch:"],
 
342
                           ['log',  '-c1234'])
 
343
 
 
344
    def test_log_change_nonexistent_dotted_revno(self):
 
345
        self.make_minimal_branch()
 
346
        self.run_bzr_error(["bzr: ERROR: Requested revision: '123.123' "
 
347
                            "does not exist in branch:"],
 
348
                           ['log', '-c123.123'])
 
349
 
 
350
    def test_log_change_single_revno_only(self):
 
351
        self.make_minimal_branch()
 
352
        self.run_bzr_error(['bzr: ERROR: Option --change does not'
 
353
                           ' accept revision ranges'],
 
354
                           ['log', '--change', '2..3'])
 
355
 
 
356
    def test_log_change_incompatible_with_revision(self):
 
357
        self.run_bzr_error(['bzr: ERROR: --revision and --change'
 
358
                           ' are mutually exclusive'],
 
359
                           ['log', '--change', '2', '--revision', '3'])
 
360
 
 
361
    def test_log_nonexistent_file(self):
 
362
        self.make_minimal_branch()
 
363
        # files that don't exist in either the basis tree or working tree
 
364
        # should give an error
 
365
        out, err = self.run_bzr('log does-not-exist', retcode=3)
 
366
        self.assertContainsRe(err,
 
367
                              'Path unknown at end or start of revision range: '
 
368
                              'does-not-exist')
117
369
 
118
370
    def test_log_reversed_revspecs(self):
119
 
        self._prepare()
 
371
        self.make_linear_branch()
120
372
        self.run_bzr_error(('bzr: ERROR: Start revision must be older than '
121
373
                            'the end revision.\n',),
122
374
                           ['log', '-r3..1'])
123
375
 
124
 
    def test_log_revno_n_path(self):
125
 
        self._prepare(path='branch1')
126
 
        self._prepare(path='branch2')
127
 
        log = self.run_bzr("log -r revno:2:branch1..revno:3:branch2",
128
 
                          retcode=3)[0]
129
 
        log = self.run_bzr("log -r revno:1:branch2..revno:3:branch2")[0]
130
 
        self.assertEqualDiff(self.full_log, log)
131
 
        log = self.run_bzr("log -r revno:1:branch2")[0]
132
 
        self.assertTrue('revno: 1\n' in log)
133
 
        self.assertTrue('revno: 2\n' not in log)
134
 
        self.assertTrue('branch nick: branch2\n' in log)
135
 
        self.assertTrue('branch nick: branch1\n' not in log)
136
 
        
137
 
    def test_log_nonexistent_file(self):
138
 
        # files that don't exist in either the basis tree or working tree
139
 
        # should give an error
140
 
        wt = self.make_branch_and_tree('.')
141
 
        out, err = self.run_bzr('log does-not-exist', retcode=3)
142
 
        self.assertContainsRe(
143
 
            err, 'Path does not have any revision history: does-not-exist')
 
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):
144
413
 
145
414
    def test_log_with_tags(self):
146
 
        tree = self._prepare(format='dirstate-tags')
 
415
        tree = self.make_linear_branch(format='dirstate-tags')
147
416
        branch = tree.branch
148
417
        branch.tags.set_tag('tag1', branch.get_rev_id(1))
149
418
        branch.tags.set_tag('tag1.1', branch.get_rev_id(1))
150
 
        branch.tags.set_tag('tag3', branch.last_revision()) 
151
 
        
 
419
        branch.tags.set_tag('tag3', branch.last_revision())
 
420
 
152
421
        log = self.run_bzr("log -r-1")[0]
153
422
        self.assertTrue('tags: tag3' in log)
154
423
 
158
427
        self.assertContainsRe(log, r'tags: (tag1, tag1\.1|tag1\.1, tag1)')
159
428
 
160
429
    def test_merged_log_with_tags(self):
161
 
        branch1_tree = self._prepare(path='branch1', format='dirstate-tags')
 
430
        branch1_tree = self.make_linear_branch('branch1',
 
431
                                               format='dirstate-tags')
162
432
        branch1 = branch1_tree.branch
163
433
        branch2_tree = branch1_tree.bzrdir.sprout('branch2').open_workingtree()
164
434
        branch1_tree.commit(message='foobar', allow_pointless=True)
165
435
        branch1.tags.set_tag('tag1', branch1.last_revision())
166
 
        os.chdir('branch2')
167
 
        self.run_bzr('merge ../branch1') # tags don't propagate otherwise
 
436
        # tags don't propagate if we don't merge
 
437
        self.run_bzr('merge ../branch1', working_dir='branch2')
168
438
        branch2_tree.commit(message='merge branch 1')
169
 
        log = self.run_bzr("log -r-1")[0]
 
439
        log = self.run_bzr("log -n0 -r-1", working_dir='branch2')[0]
170
440
        self.assertContainsRe(log, r'    tags: tag1')
171
 
        log = self.run_bzr("log -r3.1.1")[0]
 
441
        log = self.run_bzr("log -n0 -r3.1.1", working_dir='branch2')[0]
172
442
        self.assertContainsRe(log, r'tags: tag1')
173
443
 
174
 
    def test_log_limit(self):
175
 
        self._prepare()
176
 
        log = self.run_bzr("log --limit 2")[0]
177
 
        self.assertNotContainsRe(log, r'revno: 1\n')
178
 
        self.assertContainsRe(log, r'revno: 2\n')
179
 
        self.assertContainsRe(log, r'revno: 3\n')
180
 
 
181
 
    def test_log_limit_short(self):
182
 
        self._prepare()
183
 
        log = self.run_bzr("log -l 2")[0]
184
 
        self.assertNotContainsRe(log, r'revno: 1\n')
185
 
        self.assertContainsRe(log, r'revno: 2\n')
186
 
        self.assertContainsRe(log, r'revno: 3\n')
187
 
 
188
 
class TestLogMerges(ExternalBase):
189
 
 
190
 
    def _prepare(self):
191
 
        parent_tree = self.make_branch_and_tree('parent')
192
 
        parent_tree.commit(message='first post', allow_pointless=True)
193
 
        child_tree = parent_tree.bzrdir.sprout('child').open_workingtree()
194
 
        child_tree.commit(message='branch 1', allow_pointless=True)
195
 
        smaller_tree = \
196
 
                child_tree.bzrdir.sprout('smallerchild').open_workingtree()
197
 
        smaller_tree.commit(message='branch 2', allow_pointless=True)
198
 
        child_tree.merge_from_branch(smaller_tree.branch)
199
 
        child_tree.commit(message='merge branch 2')
200
 
        parent_tree.merge_from_branch(child_tree.branch)
201
 
        parent_tree.commit(message='merge branch 1')
202
 
        os.chdir('parent')
 
444
 
 
445
class TestLogVerbose(TestLog):
 
446
 
 
447
    def setUp(self):
 
448
        super(TestLogVerbose, self).setUp()
 
449
        self.make_minimal_branch()
 
450
 
 
451
    def assertUseShortDeltaFormat(self, cmd):
 
452
        log = self.run_bzr(cmd)[0]
 
453
        # Check that we use the short status format
 
454
        self.assertContainsRe(log, '(?m)^\s*A  hello.txt$')
 
455
        self.assertNotContainsRe(log, '(?m)^\s*added:$')
 
456
 
 
457
    def assertUseLongDeltaFormat(self, cmd):
 
458
        log = self.run_bzr(cmd)[0]
 
459
        # Check that we use the long status format
 
460
        self.assertNotContainsRe(log, '(?m)^\s*A  hello.txt$')
 
461
        self.assertContainsRe(log, '(?m)^\s*added:$')
 
462
 
 
463
    def test_log_short_verbose(self):
 
464
        self.assertUseShortDeltaFormat(['log', '--short', '-v'])
 
465
 
 
466
    def test_log_short_verbose_verbose(self):
 
467
        self.assertUseLongDeltaFormat(['log', '--short', '-vv'])
 
468
 
 
469
    def test_log_long_verbose(self):
 
470
        # Check that we use the long status format, ignoring the verbosity
 
471
        # level
 
472
        self.assertUseLongDeltaFormat(['log', '--long', '-v'])
 
473
 
 
474
    def test_log_long_verbose_verbose(self):
 
475
        # Check that we use the long status format, ignoring the verbosity
 
476
        # level
 
477
        self.assertUseLongDeltaFormat(['log', '--long', '-vv'])
 
478
 
 
479
 
 
480
class TestLogMerges(TestLogWithLogCatcher):
 
481
 
 
482
    def setUp(self):
 
483
        super(TestLogMerges, self).setUp()
 
484
        self.make_branches_with_merges()
 
485
 
 
486
    def make_branches_with_merges(self):
 
487
        level0 = self.make_branch_and_tree('level0')
 
488
        self.wt_commit(level0, 'in branch level0')
 
489
        level1 = level0.bzrdir.sprout('level1').open_workingtree()
 
490
        self.wt_commit(level1, 'in branch level1')
 
491
        level2 = level1.bzrdir.sprout('level2').open_workingtree()
 
492
        self.wt_commit(level2, 'in branch level2')
 
493
        level1.merge_from_branch(level2.branch)
 
494
        self.wt_commit(level1, 'merge branch level2')
 
495
        level0.merge_from_branch(level1.branch)
 
496
        self.wt_commit(level0, 'merge branch level1')
203
497
 
204
498
    def test_merges_are_indented_by_level(self):
205
 
        self._prepare()
206
 
        out,err = self.run_bzr('log')
207
 
        self.assertEqual('', err)
208
 
        log = normalize_log(out)
209
 
        self.assertEqualDiff(log, """\
210
 
------------------------------------------------------------
211
 
revno: 2
212
 
committer: Lorem Ipsum <test@example.com>
213
 
branch nick: parent
214
 
timestamp: Just now
215
 
message:
216
 
  merge branch 1
217
 
    ------------------------------------------------------------
218
 
    revno: 1.1.2
219
 
    committer: Lorem Ipsum <test@example.com>
220
 
    branch nick: child
221
 
    timestamp: Just now
222
 
    message:
223
 
      merge branch 2
224
 
        ------------------------------------------------------------
225
 
        revno: 1.2.1
226
 
        committer: Lorem Ipsum <test@example.com>
227
 
        branch nick: smallerchild
228
 
        timestamp: Just now
229
 
        message:
230
 
          branch 2
231
 
    ------------------------------------------------------------
232
 
    revno: 1.1.1
233
 
    committer: Lorem Ipsum <test@example.com>
234
 
    branch nick: child
235
 
    timestamp: Just now
236
 
    message:
237
 
      branch 1
238
 
------------------------------------------------------------
239
 
revno: 1
240
 
committer: Lorem Ipsum <test@example.com>
241
 
branch nick: parent
242
 
timestamp: Just now
243
 
message:
244
 
  first post
245
 
""")
 
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()])
 
506
 
 
507
    def test_force_merge_revisions_off(self):
 
508
        self.assertLogRevnos(['-n1'], ['2', '1'], working_dir='level0')
 
509
 
 
510
    def test_force_merge_revisions_on(self):
 
511
        self.assertLogRevnos(['-n0'], ['2', '1.1.2', '1.2.1', '1.1.1', '1'],
 
512
                             working_dir='level0')
 
513
 
 
514
    def test_include_merges(self):
 
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')
 
522
        out_im, err_im = self.run_bzr('log --include-merges',
 
523
                                      working_dir='level0')
 
524
        out_n0, err_n0 = self.run_bzr('log -n0', working_dir='level0')
 
525
        self.assertEqual('', err_im)
 
526
        self.assertEqual('', err_n0)
 
527
        self.assertEqual(out_im, out_n0)
 
528
 
 
529
    def test_force_merge_revisions_N(self):
 
530
        self.assertLogRevnos(['-n2'],
 
531
                             ['2', '1.1.2', '1.1.1', '1'],
 
532
                             working_dir='level0')
246
533
 
247
534
    def test_merges_single_merge_rev(self):
248
 
        self._prepare()
249
 
        out,err = self.run_bzr('log -r1.1.2')
250
 
        self.assertEqual('', err)
251
 
        log = normalize_log(out)
252
 
        self.assertEqualDiff(log, """\
253
 
------------------------------------------------------------
254
 
revno: 1.1.2
255
 
committer: Lorem Ipsum <test@example.com>
256
 
branch nick: child
257
 
timestamp: Just now
258
 
message:
259
 
  merge branch 2
260
 
    ------------------------------------------------------------
261
 
    revno: 1.2.1
262
 
    committer: Lorem Ipsum <test@example.com>
263
 
    branch nick: smallerchild
264
 
    timestamp: Just now
265
 
    message:
266
 
      branch 2
267
 
""")
 
535
        self.assertLogRevnosAndDepths(['-n0', '-r1.1.2'],
 
536
                                      [('1.1.2', 0), ('1.2.1', 1)],
 
537
                                      working_dir='level0')
268
538
 
269
539
    def test_merges_partial_range(self):
270
 
        self._prepare()
271
 
        out,err = self.run_bzr('log -r1.1.1..1.1.2')
272
 
        self.assertEqual('', err)
273
 
        log = normalize_log(out)
274
 
        self.assertEqualDiff(log, """\
275
 
------------------------------------------------------------
276
 
revno: 1.1.2
277
 
committer: Lorem Ipsum <test@example.com>
278
 
branch nick: child
279
 
timestamp: Just now
280
 
message:
281
 
  merge branch 2
282
 
    ------------------------------------------------------------
283
 
    revno: 1.2.1
284
 
    committer: Lorem Ipsum <test@example.com>
285
 
    branch nick: smallerchild
286
 
    timestamp: Just now
287
 
    message:
288
 
      branch 2
289
 
------------------------------------------------------------
290
 
revno: 1.1.1
291
 
committer: Lorem Ipsum <test@example.com>
292
 
branch nick: child
293
 
timestamp: Just now
294
 
message:
295
 
  branch 1
296
 
""")
297
 
 
298
 
    def test_merges_nonsupporting_formatter(self):
299
 
        self._prepare()
300
 
        err_msg = 'Selected log formatter only supports mainline revisions.'
301
 
        # The single revision case is tested in the core tests
302
 
        # since all standard formatters support single merge revisions.
303
 
        out,err = self.run_bzr('log --short -r1..1.1.2', retcode=3)
304
 
        self.assertContainsRe(err, err_msg)
305
 
        out,err = self.run_bzr('log --short -r1.1.1..1.1.2', retcode=3)
306
 
        self.assertContainsRe(err, err_msg)
307
 
 
308
 
 
309
 
class TestLogEncodings(TestCaseInTempDir):
 
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')
 
544
 
 
545
    def test_merges_partial_range_ignore_before_lower_bound(self):
 
546
        """Dont show revisions before the lower bound's merged revs"""
 
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
 
558
 
 
559
    def setUp(self):
 
560
        super(TestLogDiff, self).setUp()
 
561
        self.make_branch_with_diffs()
 
562
 
 
563
    def make_branch_with_diffs(self):
 
564
        level0 = self.make_branch_and_tree('level0')
 
565
        self.build_tree(['level0/file1', 'level0/file2'])
 
566
        level0.add('file1')
 
567
        level0.add('file2')
 
568
        self.wt_commit(level0, 'in branch level0')
 
569
 
 
570
        level1 = level0.bzrdir.sprout('level1').open_workingtree()
 
571
        self.build_tree_contents([('level1/file2', 'hello\n')])
 
572
        self.wt_commit(level1, 'in branch level1')
 
573
        level0.merge_from_branch(level1.branch)
 
574
        self.wt_commit(level0, 'merge branch level1')
 
575
 
 
576
    def _diff_file1_revno1(self):
 
577
        return """=== added file 'file1'
 
578
--- file1\t1970-01-01 00:00:00 +0000
 
579
+++ file1\t2005-11-22 00:00:00 +0000
 
580
@@ -0,0 +1,1 @@
 
581
+contents of level0/file1
 
582
 
 
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'
 
607
--- file2\t1970-01-01 00:00:00 +0000
 
608
+++ file2\t2005-11-22 00:00:00 +0000
 
609
@@ -0,0 +1,1 @@
 
610
+contents of level0/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')
 
652
 
 
653
 
 
654
class TestLogUnicodeDiff(TestLog):
 
655
 
 
656
    def test_log_show_diff_non_ascii(self):
 
657
        # Smoke test for bug #328007 UnicodeDecodeError on 'log -p'
 
658
        message = u'Message with \xb5'
 
659
        body = 'Body with \xb5\n'
 
660
        wt = self.make_branch_and_tree('.')
 
661
        self.build_tree_contents([('foo', body)])
 
662
        wt.add('foo')
 
663
        wt.commit(message=message)
 
664
        # check that command won't fail with unicode error
 
665
        # don't care about exact output because we have other tests for this
 
666
        out,err = self.run_bzr('log -p --long')
 
667
        self.assertNotEqual('', out)
 
668
        self.assertEqual('', err)
 
669
        out,err = self.run_bzr('log -p --short')
 
670
        self.assertNotEqual('', out)
 
671
        self.assertEqual('', err)
 
672
        out,err = self.run_bzr('log -p --line')
 
673
        self.assertNotEqual('', out)
 
674
        self.assertEqual('', err)
 
675
 
 
676
 
 
677
class TestLogEncodings(tests.TestCaseInTempDir):
310
678
 
311
679
    _mu = u'\xb5'
312
680
    _message = u'Message with \xb5'
317
685
        'latin-1',
318
686
        'iso-8859-1',
319
687
        'cp437', # Common windows encoding
320
 
        'cp1251', # Alexander Belchenko's windows encoding
 
688
        'cp1251', # Russian windows encoding
321
689
        'cp1258', # Common windows encoding
322
690
    ]
323
691
    # Encodings which cannot encode mu
328
696
    ]
329
697
 
330
698
    def setUp(self):
331
 
        TestCaseInTempDir.setUp(self)
332
 
        self.user_encoding = bzrlib.user_encoding
333
 
 
334
 
    def tearDown(self):
335
 
        bzrlib.user_encoding = self.user_encoding
336
 
        TestCaseInTempDir.tearDown(self)
 
699
        super(TestLogEncodings, self).setUp()
 
700
        self.overrideAttr(osutils, '_cached_user_encoding')
337
701
 
338
702
    def create_branch(self):
339
703
        bzr = self.run_bzr
340
704
        bzr('init')
341
 
        open('a', 'wb').write('some stuff\n')
 
705
        self.build_tree_contents([('a', 'some stuff\n')])
342
706
        bzr('add a')
343
707
        bzr(['commit', '-m', self._message])
344
708
 
351
715
        else:
352
716
            encoded_msg = self._message.encode(encoding)
353
717
 
354
 
        old_encoding = bzrlib.user_encoding
 
718
        old_encoding = osutils._cached_user_encoding
355
719
        # This test requires that 'run_bzr' uses the current
356
720
        # bzrlib, because we override user_encoding, and expect
357
721
        # it to be used
358
722
        try:
359
 
            bzrlib.user_encoding = 'ascii'
 
723
            osutils._cached_user_encoding = 'ascii'
360
724
            # We should be able to handle any encoding
361
725
            out, err = bzr('log', encoding=encoding)
362
726
            if not fail:
367
731
            else:
368
732
                self.assertNotEqual(-1, out.find('Message with ?'))
369
733
        finally:
370
 
            bzrlib.user_encoding = old_encoding
 
734
            osutils._cached_user_encoding = old_encoding
371
735
 
372
736
    def test_log_handles_encoding(self):
373
737
        self.create_branch()
383
747
 
384
748
    def test_stdout_encoding(self):
385
749
        bzr = self.run_bzr
386
 
        bzrlib.user_encoding = "cp1251"
 
750
        osutils._cached_user_encoding = "cp1251"
387
751
 
388
752
        bzr('init')
389
753
        self.build_tree(['a'])
407
771
        self.assertEquals(-1, stdout.find(test_in_cp1251))
408
772
 
409
773
 
410
 
class TestLogFile(TestCaseWithTransport):
 
774
class TestLogFile(TestLogWithLogCatcher):
411
775
 
412
776
    def test_log_local_branch_file(self):
413
777
        """We should be able to log files in local treeless branches"""
418
782
        tree.bzrdir.destroy_workingtree()
419
783
        self.run_bzr('log tree/file')
420
784
 
421
 
    def test_log_file(self):
422
 
        """The log for a particular file should only list revs for that file"""
 
785
    def prepare_tree(self, complex=False):
 
786
        # The complex configuration includes deletes and renames
423
787
        tree = self.make_branch_and_tree('parent')
424
788
        self.build_tree(['parent/file1', 'parent/file2', 'parent/file3'])
425
789
        tree.add('file1')
433
797
        child_tree.commit(message='branch 1')
434
798
        tree.merge_from_branch(child_tree.branch)
435
799
        tree.commit(message='merge child branch')
436
 
        os.chdir('parent')
437
 
        log = self.run_bzr('log file1')[0]
438
 
        self.assertContainsRe(log, 'revno: 1\n')
439
 
        self.assertNotContainsRe(log, 'revno: 2\n')
440
 
        self.assertNotContainsRe(log, 'revno: 3\n')
441
 
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
442
 
        self.assertNotContainsRe(log, 'revno: 4\n')
443
 
        log = self.run_bzr('log file2')[0]
444
 
        self.assertNotContainsRe(log, 'revno: 1\n')
445
 
        self.assertContainsRe(log, 'revno: 2\n')
446
 
        self.assertNotContainsRe(log, 'revno: 3\n')
447
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
448
 
        self.assertContainsRe(log, 'revno: 4\n')
449
 
        log = self.run_bzr('log file3')[0]
450
 
        self.assertNotContainsRe(log, 'revno: 1\n')
451
 
        self.assertNotContainsRe(log, 'revno: 2\n')
452
 
        self.assertContainsRe(log, 'revno: 3\n')
453
 
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
454
 
        self.assertNotContainsRe(log, 'revno: 4\n')
455
 
        log = self.run_bzr('log -r3.1.1 file2')[0]
456
 
        self.assertNotContainsRe(log, 'revno: 1\n')
457
 
        self.assertNotContainsRe(log, 'revno: 2\n')
458
 
        self.assertNotContainsRe(log, 'revno: 3\n')
459
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
460
 
        self.assertNotContainsRe(log, 'revno: 4\n')
461
 
        log = self.run_bzr('log -r4 file2')[0]
462
 
        self.assertNotContainsRe(log, 'revno: 1\n')
463
 
        self.assertNotContainsRe(log, 'revno: 2\n')
464
 
        self.assertNotContainsRe(log, 'revno: 3\n')
465
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
466
 
        self.assertContainsRe(log, 'revno: 4\n')
467
 
        log = self.run_bzr('log -r3.. file2')[0]
468
 
        self.assertNotContainsRe(log, 'revno: 1\n')
469
 
        self.assertNotContainsRe(log, 'revno: 2\n')
470
 
        self.assertNotContainsRe(log, 'revno: 3\n')
471
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
472
 
        self.assertContainsRe(log, 'revno: 4\n')
473
 
        log = self.run_bzr('log -r..3 file2')[0]
474
 
        self.assertNotContainsRe(log, 'revno: 1\n')
475
 
        self.assertContainsRe(log, 'revno: 2\n')
476
 
        self.assertNotContainsRe(log, 'revno: 3\n')
477
 
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
478
 
        self.assertNotContainsRe(log, 'revno: 4\n')
 
800
        if complex:
 
801
            tree.remove('file2')
 
802
            tree.commit('remove file2')
 
803
            tree.rename_one('file3', 'file4')
 
804
            tree.commit('file3 is now called file4')
 
805
            tree.remove('file1')
 
806
            tree.commit('remove file1')
 
807
        os.chdir('parent')
 
808
 
 
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'])
 
832
 
 
833
    def test_log_file_historical_missing(self):
 
834
        # Check logging a deleted file gives an error if the
 
835
        # file isn't found at the end or start of the revision range
 
836
        self.prepare_tree(complex=True)
 
837
        err_msg = "Path unknown at end or start of revision range: file2"
 
838
        err = self.run_bzr('log file2', retcode=3)[1]
 
839
        self.assertContainsRe(err, err_msg)
 
840
 
 
841
    def test_log_file_historical_end(self):
 
842
        # Check logging a deleted file is ok if the file existed
 
843
        # at the end the revision range
 
844
        self.prepare_tree(complex=True)
 
845
        self.assertLogRevnos(['-n0', '-r..4', 'file2'], ['4', '3.1.1', '2'])
 
846
 
 
847
    def test_log_file_historical_start(self):
 
848
        # Check logging a deleted file is ok if the file existed
 
849
        # at the start of the revision range
 
850
        self.prepare_tree(complex=True)
 
851
        self.assertLogRevnos(['file1'], ['1'])
 
852
 
 
853
    def test_log_file_renamed(self):
 
854
        """File matched against revision range, not current tree."""
 
855
        self.prepare_tree(complex=True)
 
856
 
 
857
        # Check logging a renamed file gives an error by default
 
858
        err_msg = "Path unknown at end or start of revision range: file3"
 
859
        err = self.run_bzr('log file3', retcode=3)[1]
 
860
        self.assertContainsRe(err, err_msg)
 
861
 
 
862
        # Check we can see a renamed file if we give the right end revision
 
863
        self.assertLogRevnos(['-r..4', 'file3'], ['3'])
 
864
 
 
865
 
 
866
class TestLogMultiple(TestLogWithLogCatcher):
 
867
 
 
868
    def prepare_tree(self):
 
869
        tree = self.make_branch_and_tree('parent')
 
870
        self.build_tree([
 
871
            'parent/file1',
 
872
            'parent/file2',
 
873
            'parent/dir1/',
 
874
            'parent/dir1/file5',
 
875
            'parent/dir1/dir2/',
 
876
            'parent/dir1/dir2/file3',
 
877
            'parent/file4'])
 
878
        tree.add('file1')
 
879
        tree.commit('add file1')
 
880
        tree.add('file2')
 
881
        tree.commit('add file2')
 
882
        tree.add(['dir1', 'dir1/dir2', 'dir1/dir2/file3'])
 
883
        tree.commit('add file3')
 
884
        tree.add('file4')
 
885
        tree.commit('add file4')
 
886
        tree.add('dir1/file5')
 
887
        tree.commit('add file5')
 
888
        child_tree = tree.bzrdir.sprout('child').open_workingtree()
 
889
        self.build_tree_contents([('child/file2', 'hello')])
 
890
        child_tree.commit(message='branch 1')
 
891
        tree.merge_from_branch(child_tree.branch)
 
892
        tree.commit(message='merge child branch')
 
893
        os.chdir('parent')
 
894
 
 
895
    def test_log_files(self):
 
896
        """The log for multiple file should only list revs for those files"""
 
897
        self.prepare_tree()
 
898
        self.assertLogRevnos(['file1', 'file2', 'dir1/dir2/file3'],
 
899
                             ['6', '5.1.1', '3', '2', '1'])
 
900
 
 
901
    def test_log_directory(self):
 
902
        """The log for a directory should show all nested files."""
 
903
        self.prepare_tree()
 
904
        self.assertLogRevnos(['dir1'], ['5', '3'])
 
905
 
 
906
    def test_log_nested_directory(self):
 
907
        """The log for a directory should show all nested files."""
 
908
        self.prepare_tree()
 
909
        self.assertLogRevnos(['dir1/dir2'], ['3'])
 
910
 
 
911
    def test_log_in_nested_directory(self):
 
912
        """The log for a directory should show all nested files."""
 
913
        self.prepare_tree()
 
914
        os.chdir("dir1")
 
915
        self.assertLogRevnos(['.'], ['5', '3'])
 
916
 
 
917
    def test_log_files_and_directories(self):
 
918
        """Logging files and directories together should be fine."""
 
919
        self.prepare_tree()
 
920
        self.assertLogRevnos(['file4', 'dir1/dir2'], ['4', '3'])
 
921
 
 
922
    def test_log_files_and_dirs_in_nested_directory(self):
 
923
        """The log for a directory should show all nested files."""
 
924
        self.prepare_tree()
 
925
        os.chdir("dir1")
 
926
        self.assertLogRevnos(['dir2', 'file5'], ['5', '3'])