← 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: Jelmer Vernooij
  • Date: 2010-12-20 11:57:14 UTC
  • mto: This revision was merged to the branch mainline in revision 5577.
  • Revision ID: jelmer@samba.org-20101220115714-2ru3hfappjweeg7q
Don't use no-plugins.

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_negative_begin_revspec_full_log(self):
84
 
        self._prepare()
85
 
        log = self.run_bzr("log -r -3..")[0]
86
 
        self.assertEqualDiff(self.full_log, log)
87
 
 
88
 
    def test_log_negative_both_revspec_full_log(self):
89
 
        self._prepare()
90
 
        log = self.run_bzr("log -r -3..-1")[0]
91
 
        self.assertEqualDiff(self.full_log, log)
92
 
 
93
 
    def test_log_negative_both_revspec_partial(self):
94
 
        self._prepare()
95
 
        log = self.run_bzr("log -r -3..-2")[0]
96
 
        self.assertTrue('revno: 1\n' in log)
97
 
        self.assertTrue('revno: 2\n' in log)
98
 
        self.assertTrue('revno: 3\n' not in log)
99
 
 
100
 
    def test_log_negative_begin_revspec(self):
101
 
        self._prepare()
102
 
        log = self.run_bzr("log -r -2..")[0]
103
 
        self.assertTrue('revno: 1\n' not in log)
104
 
        self.assertTrue('revno: 2\n' in log)
105
 
        self.assertTrue('revno: 3\n' in log)
106
 
 
107
 
    def test_log_positive_revspecs(self):
108
 
        self._prepare()
109
 
        log = self.run_bzr("log -r 1..3")[0]
110
 
        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')
111
369
 
112
370
    def test_log_reversed_revspecs(self):
113
 
        self._prepare()
 
371
        self.make_linear_branch()
114
372
        self.run_bzr_error(('bzr: ERROR: Start revision must be older than '
115
373
                            'the end revision.\n',),
116
374
                           ['log', '-r3..1'])
117
375
 
118
 
    def test_log_revno_n_path(self):
119
 
        self._prepare(path='branch1')
120
 
        self._prepare(path='branch2')
121
 
        log = self.run_bzr("log -r revno:2:branch1..revno:3:branch2",
122
 
                          retcode=3)[0]
123
 
        log = self.run_bzr("log -r revno:1:branch2..revno:3:branch2")[0]
124
 
        self.assertEqualDiff(self.full_log, log)
125
 
        log = self.run_bzr("log -r revno:1:branch2")[0]
126
 
        self.assertTrue('revno: 1\n' in log)
127
 
        self.assertTrue('revno: 2\n' not in log)
128
 
        self.assertTrue('branch nick: branch2\n' in log)
129
 
        self.assertTrue('branch nick: branch1\n' not in log)
130
 
        
131
 
    def test_log_nonexistent_file(self):
132
 
        # files that don't exist in either the basis tree or working tree
133
 
        # should give an error
134
 
        wt = self.make_branch_and_tree('.')
135
 
        out, err = self.run_bzr('log does-not-exist', retcode=3)
136
 
        self.assertContainsRe(
137
 
            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):
138
413
 
139
414
    def test_log_with_tags(self):
140
 
        tree = self._prepare(format='dirstate-tags')
 
415
        tree = self.make_linear_branch(format='dirstate-tags')
141
416
        branch = tree.branch
142
417
        branch.tags.set_tag('tag1', branch.get_rev_id(1))
143
418
        branch.tags.set_tag('tag1.1', branch.get_rev_id(1))
144
 
        branch.tags.set_tag('tag3', branch.last_revision()) 
145
 
        
 
419
        branch.tags.set_tag('tag3', branch.last_revision())
 
420
 
146
421
        log = self.run_bzr("log -r-1")[0]
147
422
        self.assertTrue('tags: tag3' in log)
148
423
 
152
427
        self.assertContainsRe(log, r'tags: (tag1, tag1\.1|tag1\.1, tag1)')
153
428
 
154
429
    def test_merged_log_with_tags(self):
155
 
        branch1_tree = self._prepare(path='branch1', format='dirstate-tags')
 
430
        branch1_tree = self.make_linear_branch('branch1',
 
431
                                               format='dirstate-tags')
156
432
        branch1 = branch1_tree.branch
157
433
        branch2_tree = branch1_tree.bzrdir.sprout('branch2').open_workingtree()
158
434
        branch1_tree.commit(message='foobar', allow_pointless=True)
159
435
        branch1.tags.set_tag('tag1', branch1.last_revision())
160
 
        os.chdir('branch2')
161
 
        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')
162
438
        branch2_tree.commit(message='merge branch 1')
163
 
        log = self.run_bzr("log -r-1")[0]
 
439
        log = self.run_bzr("log -n0 -r-1", working_dir='branch2')[0]
164
440
        self.assertContainsRe(log, r'    tags: tag1')
165
 
        log = self.run_bzr("log -r3.1.1")[0]
 
441
        log = self.run_bzr("log -n0 -r3.1.1", working_dir='branch2')[0]
166
442
        self.assertContainsRe(log, r'tags: tag1')
167
443
 
168
 
    def test_log_limit(self):
169
 
        self._prepare()
170
 
        log = self.run_bzr("log --limit 2")[0]
171
 
        self.assertTrue('revno: 1\n' not in log)
172
 
        self.assertTrue('revno: 2\n' in log)
173
 
        self.assertTrue('revno: 3\n' in log)
174
 
 
175
 
class TestLogMerges(ExternalBase):
176
 
 
177
 
    def _prepare(self):
178
 
        parent_tree = self.make_branch_and_tree('parent')
179
 
        parent_tree.commit(message='first post', allow_pointless=True)
180
 
        child_tree = parent_tree.bzrdir.sprout('child').open_workingtree()
181
 
        child_tree.commit(message='branch 1', allow_pointless=True)
182
 
        smaller_tree = \
183
 
                child_tree.bzrdir.sprout('smallerchild').open_workingtree()
184
 
        smaller_tree.commit(message='branch 2', allow_pointless=True)
185
 
        child_tree.merge_from_branch(smaller_tree.branch)
186
 
        child_tree.commit(message='merge branch 2')
187
 
        parent_tree.merge_from_branch(child_tree.branch)
188
 
        parent_tree.commit(message='merge branch 1')
189
 
        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')
190
497
 
191
498
    def test_merges_are_indented_by_level(self):
192
 
        self._prepare()
193
 
        out,err = self.run_bzr('log')
194
 
        self.assertEqual('', err)
195
 
        log = normalize_log(out)
196
 
        self.assertEqualDiff(log, """\
197
 
------------------------------------------------------------
198
 
revno: 2
199
 
committer: Lorem Ipsum <test@example.com>
200
 
branch nick: parent
201
 
timestamp: Just now
202
 
message:
203
 
  merge branch 1
204
 
    ------------------------------------------------------------
205
 
    revno: 1.1.2
206
 
    committer: Lorem Ipsum <test@example.com>
207
 
    branch nick: child
208
 
    timestamp: Just now
209
 
    message:
210
 
      merge branch 2
211
 
        ------------------------------------------------------------
212
 
        revno: 1.1.1.1.1
213
 
        committer: Lorem Ipsum <test@example.com>
214
 
        branch nick: smallerchild
215
 
        timestamp: Just now
216
 
        message:
217
 
          branch 2
218
 
    ------------------------------------------------------------
219
 
    revno: 1.1.1
220
 
    committer: Lorem Ipsum <test@example.com>
221
 
    branch nick: child
222
 
    timestamp: Just now
223
 
    message:
224
 
      branch 1
225
 
------------------------------------------------------------
226
 
revno: 1
227
 
committer: Lorem Ipsum <test@example.com>
228
 
branch nick: parent
229
 
timestamp: Just now
230
 
message:
231
 
  first post
232
 
""")
 
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')
233
533
 
234
534
    def test_merges_single_merge_rev(self):
235
 
        self._prepare()
236
 
        out,err = self.run_bzr('log -r1.1.2')
237
 
        self.assertEqual('', err)
238
 
        log = normalize_log(out)
239
 
        self.assertEqualDiff(log, """\
240
 
------------------------------------------------------------
241
 
revno: 1.1.2
242
 
committer: Lorem Ipsum <test@example.com>
243
 
branch nick: child
244
 
timestamp: Just now
245
 
message:
246
 
  merge branch 2
247
 
    ------------------------------------------------------------
248
 
    revno: 1.1.1.1.1
249
 
    committer: Lorem Ipsum <test@example.com>
250
 
    branch nick: smallerchild
251
 
    timestamp: Just now
252
 
    message:
253
 
      branch 2
254
 
""")
 
535
        self.assertLogRevnosAndDepths(['-n0', '-r1.1.2'],
 
536
                                      [('1.1.2', 0), ('1.2.1', 1)],
 
537
                                      working_dir='level0')
255
538
 
256
539
    def test_merges_partial_range(self):
257
 
        self._prepare()
258
 
        out,err = self.run_bzr('log -r1.1.1..1.1.2')
259
 
        self.assertEqual('', err)
260
 
        log = normalize_log(out)
261
 
        self.assertEqualDiff(log, """\
262
 
------------------------------------------------------------
263
 
revno: 1.1.2
264
 
committer: Lorem Ipsum <test@example.com>
265
 
branch nick: child
266
 
timestamp: Just now
267
 
message:
268
 
  merge branch 2
269
 
    ------------------------------------------------------------
270
 
    revno: 1.1.1.1.1
271
 
    committer: Lorem Ipsum <test@example.com>
272
 
    branch nick: smallerchild
273
 
    timestamp: Just now
274
 
    message:
275
 
      branch 2
276
 
------------------------------------------------------------
277
 
revno: 1.1.1
278
 
committer: Lorem Ipsum <test@example.com>
279
 
branch nick: child
280
 
timestamp: Just now
281
 
message:
282
 
  branch 1
283
 
""")
284
 
 
285
 
    def test_merges_nonsupporting_formatter(self):
286
 
        self._prepare()
287
 
        err_msg = 'Selected log formatter only supports mainline revisions.'
288
 
        out,err = self.run_bzr('log --short -r1.1.2', retcode=3)
289
 
        self.assertContainsRe(err, err_msg)
290
 
        out,err = self.run_bzr('log --short -r1..1.1.2', retcode=3)
291
 
        self.assertContainsRe(err, err_msg)
292
 
        out,err = self.run_bzr('log --short -r1.1.1..1.1.2', retcode=3)
293
 
        self.assertContainsRe(err, err_msg)
294
 
 
295
 
 
296
 
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):
297
678
 
298
679
    _mu = u'\xb5'
299
680
    _message = u'Message with \xb5'
304
685
        'latin-1',
305
686
        'iso-8859-1',
306
687
        'cp437', # Common windows encoding
307
 
        'cp1251', # Alexander Belchenko's windows encoding
 
688
        'cp1251', # Russian windows encoding
308
689
        'cp1258', # Common windows encoding
309
690
    ]
310
691
    # Encodings which cannot encode mu
315
696
    ]
316
697
 
317
698
    def setUp(self):
318
 
        TestCaseInTempDir.setUp(self)
319
 
        self.user_encoding = bzrlib.user_encoding
320
 
 
321
 
    def tearDown(self):
322
 
        bzrlib.user_encoding = self.user_encoding
323
 
        TestCaseInTempDir.tearDown(self)
 
699
        super(TestLogEncodings, self).setUp()
 
700
        self.overrideAttr(osutils, '_cached_user_encoding')
324
701
 
325
702
    def create_branch(self):
326
703
        bzr = self.run_bzr
327
704
        bzr('init')
328
 
        open('a', 'wb').write('some stuff\n')
 
705
        self.build_tree_contents([('a', 'some stuff\n')])
329
706
        bzr('add a')
330
707
        bzr(['commit', '-m', self._message])
331
708
 
338
715
        else:
339
716
            encoded_msg = self._message.encode(encoding)
340
717
 
341
 
        old_encoding = bzrlib.user_encoding
 
718
        old_encoding = osutils._cached_user_encoding
342
719
        # This test requires that 'run_bzr' uses the current
343
720
        # bzrlib, because we override user_encoding, and expect
344
721
        # it to be used
345
722
        try:
346
 
            bzrlib.user_encoding = 'ascii'
 
723
            osutils._cached_user_encoding = 'ascii'
347
724
            # We should be able to handle any encoding
348
725
            out, err = bzr('log', encoding=encoding)
349
726
            if not fail:
354
731
            else:
355
732
                self.assertNotEqual(-1, out.find('Message with ?'))
356
733
        finally:
357
 
            bzrlib.user_encoding = old_encoding
 
734
            osutils._cached_user_encoding = old_encoding
358
735
 
359
736
    def test_log_handles_encoding(self):
360
737
        self.create_branch()
370
747
 
371
748
    def test_stdout_encoding(self):
372
749
        bzr = self.run_bzr
373
 
        bzrlib.user_encoding = "cp1251"
 
750
        osutils._cached_user_encoding = "cp1251"
374
751
 
375
752
        bzr('init')
376
753
        self.build_tree(['a'])
394
771
        self.assertEquals(-1, stdout.find(test_in_cp1251))
395
772
 
396
773
 
397
 
class TestLogFile(TestCaseWithTransport):
 
774
class TestLogFile(TestLogWithLogCatcher):
398
775
 
399
776
    def test_log_local_branch_file(self):
400
777
        """We should be able to log files in local treeless branches"""
405
782
        tree.bzrdir.destroy_workingtree()
406
783
        self.run_bzr('log tree/file')
407
784
 
408
 
    def test_log_file(self):
409
 
        """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
410
787
        tree = self.make_branch_and_tree('parent')
411
788
        self.build_tree(['parent/file1', 'parent/file2', 'parent/file3'])
412
789
        tree.add('file1')
420
797
        child_tree.commit(message='branch 1')
421
798
        tree.merge_from_branch(child_tree.branch)
422
799
        tree.commit(message='merge child branch')
423
 
        os.chdir('parent')
424
 
        log = self.run_bzr('log file1')[0]
425
 
        self.assertContainsRe(log, 'revno: 1\n')
426
 
        self.assertNotContainsRe(log, 'revno: 2\n')
427
 
        self.assertNotContainsRe(log, 'revno: 3\n')
428
 
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
429
 
        self.assertNotContainsRe(log, 'revno: 4\n')
430
 
        log = self.run_bzr('log file2')[0]
431
 
        self.assertNotContainsRe(log, 'revno: 1\n')
432
 
        self.assertContainsRe(log, 'revno: 2\n')
433
 
        self.assertNotContainsRe(log, 'revno: 3\n')
434
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
435
 
        self.assertContainsRe(log, 'revno: 4\n')
436
 
        log = self.run_bzr('log file3')[0]
437
 
        self.assertNotContainsRe(log, 'revno: 1\n')
438
 
        self.assertNotContainsRe(log, 'revno: 2\n')
439
 
        self.assertContainsRe(log, 'revno: 3\n')
440
 
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
441
 
        self.assertNotContainsRe(log, 'revno: 4\n')
442
 
        log = self.run_bzr('log -r3.1.1 file2')[0]
443
 
        self.assertNotContainsRe(log, 'revno: 1\n')
444
 
        self.assertNotContainsRe(log, 'revno: 2\n')
445
 
        self.assertNotContainsRe(log, 'revno: 3\n')
446
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
447
 
        self.assertNotContainsRe(log, 'revno: 4\n')
448
 
        log = self.run_bzr('log -r4 file2')[0]
449
 
        self.assertNotContainsRe(log, 'revno: 1\n')
450
 
        self.assertNotContainsRe(log, 'revno: 2\n')
451
 
        self.assertNotContainsRe(log, 'revno: 3\n')
452
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
453
 
        self.assertContainsRe(log, 'revno: 4\n')
454
 
        log = self.run_bzr('log -r3.. file2')[0]
455
 
        self.assertNotContainsRe(log, 'revno: 1\n')
456
 
        self.assertNotContainsRe(log, 'revno: 2\n')
457
 
        self.assertNotContainsRe(log, 'revno: 3\n')
458
 
        self.assertContainsRe(log, 'revno: 3.1.1\n')
459
 
        self.assertContainsRe(log, 'revno: 4\n')
460
 
        log = self.run_bzr('log -r..3 file2')[0]
461
 
        self.assertNotContainsRe(log, 'revno: 1\n')
462
 
        self.assertContainsRe(log, 'revno: 2\n')
463
 
        self.assertNotContainsRe(log, 'revno: 3\n')
464
 
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
465
 
        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'])