← 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: 2007-10-24 12:49:17 UTC
  • mfrom: (2935.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20071024124917-xb75eckyxx6vkrlg
Makefile fixes - hooks.html generation & allow python to be overridden (Ian Clatworthy)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_log.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
# -*- coding: utf-8 -*-
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
22
22
 
23
23
import bzrlib
24
24
from bzrlib.tests.blackbox import ExternalBase
25
 
from bzrlib.tests import TestCaseInTempDir
 
25
from bzrlib.tests import TestCaseInTempDir, TestCaseWithTransport
26
26
 
27
27
 
28
28
class TestLog(ExternalBase):
29
29
 
30
 
    def _prepare(self):
31
 
        self.runbzr("init")
32
 
        self.build_tree(['hello.txt', 'goodbye.txt', 'meep.txt'])
33
 
        self.runbzr("add hello.txt")
34
 
        self.runbzr("commit -m message1 hello.txt")
35
 
        self.runbzr("add goodbye.txt")
36
 
        self.runbzr("commit -m message2 goodbye.txt")
37
 
        self.runbzr("add meep.txt")
38
 
        self.runbzr("commit -m message3 meep.txt")
39
 
        self.full_log = self.runbzr("log")[0]
 
30
    def _prepare(self, path='.', format=None):
 
31
        tree = self.make_branch_and_tree(path, format=format)
 
32
        self.build_tree(
 
33
            [path + '/hello.txt', path + '/goodbye.txt', path + '/meep.txt'])
 
34
        tree.add('hello.txt')
 
35
        tree.commit(message='message1')
 
36
        tree.add('goodbye.txt')
 
37
        tree.commit(message='message2')
 
38
        tree.add('meep.txt')
 
39
        tree.commit(message='message3')
 
40
        self.full_log = self.run_bzr(["log", path])[0]
 
41
        return tree
40
42
 
41
43
    def test_log_null_end_revspec(self):
42
44
        self._prepare()
47
49
        self.assertTrue('message:\n  message2\n' in self.full_log)
48
50
        self.assertTrue('message:\n  message3\n' in self.full_log)
49
51
 
50
 
        log = self.runbzr("log -r 1..")[0]
51
 
        self.assertEquals(log, self.full_log)
 
52
        log = self.run_bzr("log -r 1..")[0]
 
53
        self.assertEqualDiff(log, self.full_log)
52
54
 
53
55
    def test_log_null_begin_revspec(self):
54
56
        self._prepare()
55
 
        log = self.runbzr("log -r ..3")[0]
56
 
        self.assertEquals(self.full_log, log)
 
57
        log = self.run_bzr("log -r ..3")[0]
 
58
        self.assertEqualDiff(self.full_log, log)
57
59
 
58
60
    def test_log_null_both_revspecs(self):
59
61
        self._prepare()
60
 
        log = self.runbzr("log -r ..")[0]
 
62
        log = self.run_bzr("log -r ..")[0]
61
63
        self.assertEquals(self.full_log, log)
 
64
        self.assertEqualDiff(self.full_log, log)
62
65
 
63
66
    def test_log_negative_begin_revspec_full_log(self):
64
67
        self._prepare()
65
 
        log = self.runbzr("log -r -3..")[0]
66
 
        self.assertEquals(self.full_log, log)
 
68
        log = self.run_bzr("log -r -3..")[0]
 
69
        self.assertEqualDiff(self.full_log, log)
67
70
 
68
71
    def test_log_negative_both_revspec_full_log(self):
69
72
        self._prepare()
70
 
        log = self.runbzr("log -r -3..-1")[0]
71
 
        self.assertEquals(self.full_log, log)
 
73
        log = self.run_bzr("log -r -3..-1")[0]
 
74
        self.assertEqualDiff(self.full_log, log)
72
75
 
73
76
    def test_log_negative_both_revspec_partial(self):
74
77
        self._prepare()
75
 
        log = self.runbzr("log -r -3..-2")[0]
 
78
        log = self.run_bzr("log -r -3..-2")[0]
76
79
        self.assertTrue('revno: 1\n' in log)
77
80
        self.assertTrue('revno: 2\n' in log)
78
81
        self.assertTrue('revno: 3\n' not in log)
79
82
 
80
83
    def test_log_negative_begin_revspec(self):
81
84
        self._prepare()
82
 
        log = self.runbzr("log -r -2..")[0]
 
85
        log = self.run_bzr("log -r -2..")[0]
83
86
        self.assertTrue('revno: 1\n' not in log)
84
87
        self.assertTrue('revno: 2\n' in log)
85
88
        self.assertTrue('revno: 3\n' in log)
86
89
 
87
90
    def test_log_postive_revspecs(self):
88
91
        self._prepare()
89
 
        log = self.runbzr("log -r 1..3")[0]
90
 
        self.assertEquals(self.full_log, log)
91
 
 
 
92
        log = self.run_bzr("log -r 1..3")[0]
 
93
        self.assertEqualDiff(self.full_log, log)
 
94
 
 
95
    def test_log_reversed_revspecs(self):
 
96
        self._prepare()
 
97
        self.run_bzr_error(('bzr: ERROR: Start revision must be older than '
 
98
                            'the end revision.\n',),
 
99
                           ['log', '-r3..1'])
 
100
 
 
101
    def test_log_revno_n_path(self):
 
102
        self._prepare(path='branch1')
 
103
        self._prepare(path='branch2')
 
104
        log = self.run_bzr("log -r revno:2:branch1..revno:3:branch2",
 
105
                          retcode=3)[0]
 
106
        log = self.run_bzr("log -r revno:1:branch2..revno:3:branch2")[0]
 
107
        self.assertEqualDiff(self.full_log, log)
 
108
        log = self.run_bzr("log -r revno:1:branch2")[0]
 
109
        self.assertTrue('revno: 1\n' in log)
 
110
        self.assertTrue('revno: 2\n' not in log)
 
111
        self.assertTrue('branch nick: branch2\n' in log)
 
112
        self.assertTrue('branch nick: branch1\n' not in log)
 
113
        
 
114
    def test_log_nonexistent_file(self):
 
115
        # files that don't exist in either the basis tree or working tree
 
116
        # should give an error
 
117
        wt = self.make_branch_and_tree('.')
 
118
        out, err = self.run_bzr('log does-not-exist', retcode=3)
 
119
        self.assertContainsRe(
 
120
            err, 'Path does not have any revision history: does-not-exist')
 
121
 
 
122
    def test_log_with_tags(self):
 
123
        tree = self._prepare(format='dirstate-tags')
 
124
        branch = tree.branch
 
125
        branch.tags.set_tag('tag1', branch.get_rev_id(1))
 
126
        branch.tags.set_tag('tag1.1', branch.get_rev_id(1))
 
127
        branch.tags.set_tag('tag3', branch.last_revision()) 
 
128
        
 
129
        log = self.run_bzr("log -r-1")[0]
 
130
        self.assertTrue('tags: tag3' in log)
 
131
 
 
132
        log = self.run_bzr("log -r1")[0]
 
133
        # I guess that we can't know the order of tags in the output
 
134
        # since dicts are unordered, need to check both possibilities
 
135
        self.assertContainsRe(log, r'tags: (tag1, tag1\.1|tag1\.1, tag1)')
 
136
 
 
137
    def test_merged_log_with_tags(self):
 
138
        branch1_tree = self._prepare(path='branch1', format='dirstate-tags')
 
139
        branch1 = branch1_tree.branch
 
140
        branch2_tree = branch1_tree.bzrdir.sprout('branch2').open_workingtree()
 
141
        branch1_tree.commit(message='foobar', allow_pointless=True)
 
142
        branch1.tags.set_tag('tag1', branch1.last_revision())
 
143
        os.chdir('branch2')
 
144
        self.run_bzr('merge ../branch1') # tags don't propagate otherwise
 
145
        branch2_tree.commit(message='merge branch 1')
 
146
        log = self.run_bzr("log -r-1")[0]
 
147
        self.assertContainsRe(log, r'    tags: tag1')
 
148
        log = self.run_bzr("log -r3.1.1")[0]
 
149
        self.assertContainsRe(log, r'tags: tag1')
 
150
 
 
151
    def test_log_limit(self):
 
152
        self._prepare()
 
153
        log = self.run_bzr("log --limit 2")[0]
 
154
        self.assertTrue('revno: 1\n' not in log)
 
155
        self.assertTrue('revno: 2\n' in log)
 
156
        self.assertTrue('revno: 3\n' in log)
92
157
 
93
158
class TestLogMerges(ExternalBase):
94
159
 
 
160
    def _prepare(self):
 
161
        parent_tree = self.make_branch_and_tree('parent')
 
162
        parent_tree.commit(message='first post', allow_pointless=True)
 
163
        child_tree = parent_tree.bzrdir.sprout('child').open_workingtree()
 
164
        child_tree.commit(message='branch 1', allow_pointless=True)
 
165
        smaller_tree = \
 
166
                child_tree.bzrdir.sprout('smallerchild').open_workingtree()
 
167
        smaller_tree.commit(message='branch 2', allow_pointless=True)
 
168
        child_tree.merge_from_branch(smaller_tree.branch)
 
169
        child_tree.commit(message='merge branch 2')
 
170
        parent_tree.merge_from_branch(child_tree.branch)
 
171
        parent_tree.commit(message='merge branch 1')
 
172
        os.chdir('parent')
 
173
 
95
174
    def test_merges_are_indented_by_level(self):
96
 
        self.build_tree(['parent/'])
97
 
        self.run_bzr('init', 'parent')
98
 
        self.run_bzr('commit', '-m', 'first post', '--unchanged', 'parent')
99
 
        self.run_bzr('branch', 'parent', 'child')
100
 
        self.run_bzr('commit', '-m', 'branch 1', '--unchanged', 'child')
101
 
        self.run_bzr('branch', 'child', 'smallerchild')
102
 
        self.run_bzr('commit', '-m', 'branch 2', '--unchanged', 'smallerchild')
103
 
        os.chdir('child')
104
 
        self.run_bzr('merge', '../smallerchild')
105
 
        self.run_bzr('commit', '-m', 'merge branch 2')
106
 
        os.chdir('../parent')
107
 
        self.run_bzr('merge', '../child')
108
 
        self.run_bzr('commit', '-m', 'merge branch 1')
 
175
        self._prepare()
109
176
        out,err = self.run_bzr('log')
110
177
        # the log will look something like:
111
178
#        self.assertEqual("""\
117
184
#message:
118
185
#  merge branch 1
119
186
#    ------------------------------------------------------------
120
 
#    merged: foo@example.com-20060328113140-91f43cfb46dc2863
 
187
#    revno: 1.1.2  
121
188
#    committer: Robert Collins <foo@example.com>
122
189
#    branch nick: child
123
190
#    timestamp: Tue 2006-03-28 22:31:40 +1100
124
191
#    message:
125
192
#      merge branch 2
126
193
#        ------------------------------------------------------------
127
 
#        merged: foo@example.com-20060328113140-1ba24f850a0ef573
 
194
#        revno: 1.1.1.1
128
195
#        committer: Robert Collins <foo@example.com>
129
196
#        branch nick: smallerchild
130
197
#        timestamp: Tue 2006-03-28 22:31:40 +1100
131
198
#        message:
132
199
#          branch 2
133
200
#    ------------------------------------------------------------
134
 
#    merged: foo@example.com-20060328113140-5749a4757a8ac792
 
201
#    revno: 1.1.1
135
202
#    committer: Robert Collins <foo@example.com>
136
203
#    branch nick: child
137
204
#    timestamp: Tue 2006-03-28 22:31:40 +1100
146
213
#  first post
147
214
#""", out)
148
215
        # but we dont have a nice pattern matcher hooked up yet, so:
149
 
        # we check for the indenting of the commit message:
 
216
        # we check for the indenting of the commit message and the 
 
217
        # revision numbers 
 
218
        self.assertTrue('revno: 2' in out)
150
219
        self.assertTrue('  merge branch 1' in out)
 
220
        self.assertTrue('    revno: 1.1.2' in out)
151
221
        self.assertTrue('      merge branch 2' in out)
 
222
        self.assertTrue('        revno: 1.1.1.1' in out)
152
223
        self.assertTrue('          branch 2' in out)
 
224
        self.assertTrue('    revno: 1.1.1' in out)
153
225
        self.assertTrue('      branch 1' in out)
 
226
        self.assertTrue('revno: 1\n' in out)
154
227
        self.assertTrue('  first post' in out)
155
228
        self.assertEqual('', err)
156
229
 
157
 
 
 
230
    def test_merges_single_merge_rev(self):
 
231
        self._prepare()
 
232
        out,err = self.run_bzr('log -r1.1.2')
 
233
        # the log will look something like:
 
234
#        self.assertEqual("""\
 
235
#------------------------------------------------------------
 
236
#revno: 1.1.2  
 
237
#committer: Robert Collins <foo@example.com>
 
238
#branch nick: child
 
239
#timestamp: Tue 2006-03-28 22:31:40 +1100
 
240
#message:
 
241
#  merge branch 2
 
242
#    ------------------------------------------------------------
 
243
#    revno: 1.1.1.1
 
244
#    committer: Robert Collins <foo@example.com>
 
245
#    branch nick: smallerchild
 
246
#    timestamp: Tue 2006-03-28 22:31:40 +1100
 
247
#    message:
 
248
#      branch 2
 
249
#""", out)
 
250
        # but we dont have a nice pattern matcher hooked up yet, so:
 
251
        # we check for the indenting of the commit message and the 
 
252
        # revision numbers 
 
253
        self.assertTrue('revno: 2' not in out)
 
254
        self.assertTrue('  merge branch 1' not in out)
 
255
        self.assertTrue('revno: 1.1.2' in out)
 
256
        self.assertTrue('  merge branch 2' in out)
 
257
        self.assertTrue('    revno: 1.1.1.1' in out)
 
258
        self.assertTrue('      branch 2' in out)
 
259
        self.assertTrue('revno: 1.1.1\n' not in out)
 
260
        self.assertTrue('  branch 1' not in out)
 
261
        self.assertTrue('revno: 1\n' not in out)
 
262
        self.assertTrue('  first post' not in out)
 
263
        self.assertEqual('', err)
 
264
 
 
265
    def test_merges_partial_range(self):
 
266
        self._prepare()
 
267
        out,err = self.run_bzr('log -r1.1.1..1.1.2')
 
268
        # the log will look something like:
 
269
#        self.assertEqual("""\
 
270
#------------------------------------------------------------
 
271
#revno: 1.1.2  
 
272
#committer: Robert Collins <foo@example.com>
 
273
#branch nick: child
 
274
#timestamp: Tue 2006-03-28 22:31:40 +1100
 
275
#message:
 
276
#  merge branch 2
 
277
#    ------------------------------------------------------------
 
278
#    revno: 1.1.1.1
 
279
#    committer: Robert Collins <foo@example.com>
 
280
#    branch nick: smallerchild
 
281
#    timestamp: Tue 2006-03-28 22:31:40 +1100
 
282
#    message:
 
283
#      branch 2
 
284
#------------------------------------------------------------
 
285
#revno: 1.1.1
 
286
#committer: Robert Collins <foo@example.com>
 
287
#branch nick: child
 
288
#timestamp: Tue 2006-03-28 22:31:40 +1100
 
289
#message:
 
290
#  branch 1
 
291
#""", out)
 
292
        # but we dont have a nice pattern matcher hooked up yet, so:
 
293
        # we check for the indenting of the commit message and the 
 
294
        # revision numbers 
 
295
        self.assertTrue('revno: 2' not in out)
 
296
        self.assertTrue('  merge branch 1' not in out)
 
297
        self.assertTrue('revno: 1.1.2' in out)
 
298
        self.assertTrue('  merge branch 2' in out)
 
299
        self.assertTrue('    revno: 1.1.1.1' in out)
 
300
        self.assertTrue('      branch 2' in out)
 
301
        self.assertTrue('revno: 1.1.1' in out)
 
302
        self.assertTrue('  branch 1' in out)
 
303
        self.assertTrue('revno: 1\n' not in out)
 
304
        self.assertTrue('  first post' not in out)
 
305
        self.assertEqual('', err)
 
306
 
 
307
 
158
308
class TestLogEncodings(TestCaseInTempDir):
159
309
 
160
310
    _mu = u'\xb5'
188
338
        bzr = self.run_bzr
189
339
        bzr('init')
190
340
        open('a', 'wb').write('some stuff\n')
191
 
        bzr('add', 'a')
192
 
        bzr('commit', '-m', self._message)
 
341
        bzr('add a')
 
342
        bzr(['commit', '-m', self._message])
193
343
 
194
344
    def try_encoding(self, encoding, fail=False):
195
345
        bzr = self.run_bzr
236
386
 
237
387
        bzr('init')
238
388
        self.build_tree(['a'])
239
 
        bzr('add', 'a')
240
 
        bzr('commit', '-m', u'\u0422\u0435\u0441\u0442')
 
389
        bzr('add a')
 
390
        bzr(['commit', '-m', u'\u0422\u0435\u0441\u0442'])
241
391
        stdout, stderr = self.run_bzr('log', encoding='cp866')
242
392
 
243
393
        message = stdout.splitlines()[-1]
255
405
        # Make sure the cp1251 string is not found anywhere
256
406
        self.assertEquals(-1, stdout.find(test_in_cp1251))
257
407
 
 
408
 
 
409
class TestLogFile(TestCaseWithTransport):
 
410
 
 
411
    def test_log_local_branch_file(self):
 
412
        """We should be able to log files in local treeless branches"""
 
413
        tree = self.make_branch_and_tree('tree')
 
414
        self.build_tree(['tree/file'])
 
415
        tree.add('file')
 
416
        tree.commit('revision 1')
 
417
        tree.bzrdir.destroy_workingtree()
 
418
        self.run_bzr('log tree/file')
 
419
 
 
420
    def test_log_file(self):
 
421
        """The log for a particular file should only list revs for that file"""
 
422
        tree = self.make_branch_and_tree('parent')
 
423
        self.build_tree(['parent/file1', 'parent/file2', 'parent/file3'])
 
424
        tree.add('file1')
 
425
        tree.commit('add file1')
 
426
        tree.add('file2')
 
427
        tree.commit('add file2')
 
428
        tree.add('file3')
 
429
        tree.commit('add file3')
 
430
        child_tree = tree.bzrdir.sprout('child').open_workingtree()
 
431
        self.build_tree_contents([('child/file2', 'hello')])
 
432
        child_tree.commit(message='branch 1')
 
433
        tree.merge_from_branch(child_tree.branch)
 
434
        tree.commit(message='merge child branch')
 
435
        os.chdir('parent')
 
436
        log = self.run_bzr('log file1')[0]
 
437
        self.assertContainsRe(log, 'revno: 1\n')
 
438
        self.assertNotContainsRe(log, 'revno: 2\n')
 
439
        self.assertNotContainsRe(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 file2')[0]
 
443
        self.assertNotContainsRe(log, 'revno: 1\n')
 
444
        self.assertContainsRe(log, 'revno: 2\n')
 
445
        self.assertNotContainsRe(log, 'revno: 3\n')
 
446
        self.assertContainsRe(log, 'revno: 3.1.1\n')
 
447
        self.assertContainsRe(log, 'revno: 4\n')
 
448
        log = self.run_bzr('log file3')[0]
 
449
        self.assertNotContainsRe(log, 'revno: 1\n')
 
450
        self.assertNotContainsRe(log, 'revno: 2\n')
 
451
        self.assertContainsRe(log, 'revno: 3\n')
 
452
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
 
453
        self.assertNotContainsRe(log, 'revno: 4\n')
 
454
        log = self.run_bzr('log -r3.1.1 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.assertNotContainsRe(log, 'revno: 4\n')
 
460
        log = self.run_bzr('log -r4 file2')[0]
 
461
        self.assertNotContainsRe(log, 'revno: 1\n')
 
462
        self.assertNotContainsRe(log, 'revno: 2\n')
 
463
        self.assertNotContainsRe(log, 'revno: 3\n')
 
464
        self.assertContainsRe(log, 'revno: 3.1.1\n')
 
465
        self.assertContainsRe(log, 'revno: 4\n')
 
466
        log = self.run_bzr('log -r3.. file2')[0]
 
467
        self.assertNotContainsRe(log, 'revno: 1\n')
 
468
        self.assertNotContainsRe(log, 'revno: 2\n')
 
469
        self.assertNotContainsRe(log, 'revno: 3\n')
 
470
        self.assertContainsRe(log, 'revno: 3.1.1\n')
 
471
        self.assertContainsRe(log, 'revno: 4\n')
 
472
        log = self.run_bzr('log -r..3 file2')[0]
 
473
        self.assertNotContainsRe(log, 'revno: 1\n')
 
474
        self.assertContainsRe(log, 'revno: 2\n')
 
475
        self.assertNotContainsRe(log, 'revno: 3\n')
 
476
        self.assertNotContainsRe(log, 'revno: 3.1.1\n')
 
477
        self.assertNotContainsRe(log, 'revno: 4\n')