← 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: 2006-08-17 07:52:09 UTC
  • mfrom: (1910.3.4 trivial)
  • Revision ID: pqm@pqm.ubuntu.com-20060817075209-e85a1f9e05ff8b87
(andrew) Trivial fixes to NotImplemented errors.

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
 
1
# Copyright (C) 2005 by 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, TestCaseWithTransport
 
25
from bzrlib.tests import TestCaseInTempDir
26
26
 
27
27
 
28
28
class TestLog(ExternalBase):
29
29
 
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
 
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]
42
40
 
43
41
    def test_log_null_end_revspec(self):
44
42
        self._prepare()
49
47
        self.assertTrue('message:\n  message2\n' in self.full_log)
50
48
        self.assertTrue('message:\n  message3\n' in self.full_log)
51
49
 
52
 
        log = self.run_bzr("log -r 1..")[0]
53
 
        self.assertEqualDiff(log, self.full_log)
 
50
        log = self.runbzr("log -r 1..")[0]
 
51
        self.assertEquals(log, self.full_log)
54
52
 
55
53
    def test_log_null_begin_revspec(self):
56
54
        self._prepare()
57
 
        log = self.run_bzr("log -r ..3")[0]
58
 
        self.assertEqualDiff(self.full_log, log)
 
55
        log = self.runbzr("log -r ..3")[0]
 
56
        self.assertEquals(self.full_log, log)
59
57
 
60
58
    def test_log_null_both_revspecs(self):
61
59
        self._prepare()
62
 
        log = self.run_bzr("log -r ..")[0]
 
60
        log = self.runbzr("log -r ..")[0]
63
61
        self.assertEquals(self.full_log, log)
64
 
        self.assertEqualDiff(self.full_log, log)
65
62
 
66
63
    def test_log_negative_begin_revspec_full_log(self):
67
64
        self._prepare()
68
 
        log = self.run_bzr("log -r -3..")[0]
69
 
        self.assertEqualDiff(self.full_log, log)
 
65
        log = self.runbzr("log -r -3..")[0]
 
66
        self.assertEquals(self.full_log, log)
70
67
 
71
68
    def test_log_negative_both_revspec_full_log(self):
72
69
        self._prepare()
73
 
        log = self.run_bzr("log -r -3..-1")[0]
74
 
        self.assertEqualDiff(self.full_log, log)
 
70
        log = self.runbzr("log -r -3..-1")[0]
 
71
        self.assertEquals(self.full_log, log)
75
72
 
76
73
    def test_log_negative_both_revspec_partial(self):
77
74
        self._prepare()
78
 
        log = self.run_bzr("log -r -3..-2")[0]
 
75
        log = self.runbzr("log -r -3..-2")[0]
79
76
        self.assertTrue('revno: 1\n' in log)
80
77
        self.assertTrue('revno: 2\n' in log)
81
78
        self.assertTrue('revno: 3\n' not in log)
82
79
 
83
80
    def test_log_negative_begin_revspec(self):
84
81
        self._prepare()
85
 
        log = self.run_bzr("log -r -2..")[0]
 
82
        log = self.runbzr("log -r -2..")[0]
86
83
        self.assertTrue('revno: 1\n' not in log)
87
84
        self.assertTrue('revno: 2\n' in log)
88
85
        self.assertTrue('revno: 3\n' in log)
89
86
 
90
87
    def test_log_postive_revspecs(self):
91
88
        self._prepare()
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)
 
89
        log = self.runbzr("log -r 1..3")[0]
 
90
        self.assertEquals(self.full_log, log)
 
91
 
157
92
 
158
93
class TestLogMerges(ExternalBase):
159
94
 
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
 
 
174
95
    def test_merges_are_indented_by_level(self):
175
 
        self._prepare()
 
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')
176
109
        out,err = self.run_bzr('log')
177
110
        # the log will look something like:
178
111
#        self.assertEqual("""\
184
117
#message:
185
118
#  merge branch 1
186
119
#    ------------------------------------------------------------
187
 
#    revno: 1.1.2  
 
120
#    merged: foo@example.com-20060328113140-91f43cfb46dc2863
188
121
#    committer: Robert Collins <foo@example.com>
189
122
#    branch nick: child
190
123
#    timestamp: Tue 2006-03-28 22:31:40 +1100
191
124
#    message:
192
125
#      merge branch 2
193
126
#        ------------------------------------------------------------
194
 
#        revno: 1.1.1.1
 
127
#        merged: foo@example.com-20060328113140-1ba24f850a0ef573
195
128
#        committer: Robert Collins <foo@example.com>
196
129
#        branch nick: smallerchild
197
130
#        timestamp: Tue 2006-03-28 22:31:40 +1100
198
131
#        message:
199
132
#          branch 2
200
133
#    ------------------------------------------------------------
201
 
#    revno: 1.1.1
 
134
#    merged: foo@example.com-20060328113140-5749a4757a8ac792
202
135
#    committer: Robert Collins <foo@example.com>
203
136
#    branch nick: child
204
137
#    timestamp: Tue 2006-03-28 22:31:40 +1100
213
146
#  first post
214
147
#""", out)
215
148
        # but we dont have a nice pattern matcher hooked up yet, so:
216
 
        # we check for the indenting of the commit message and the 
217
 
        # revision numbers 
218
 
        self.assertTrue('revno: 2' in out)
 
149
        # we check for the indenting of the commit message:
219
150
        self.assertTrue('  merge branch 1' in out)
220
 
        self.assertTrue('    revno: 1.1.2' in out)
221
151
        self.assertTrue('      merge branch 2' in out)
222
 
        self.assertTrue('        revno: 1.1.1.1' in out)
223
152
        self.assertTrue('          branch 2' in out)
224
 
        self.assertTrue('    revno: 1.1.1' in out)
225
153
        self.assertTrue('      branch 1' in out)
226
 
        self.assertTrue('revno: 1\n' in out)
227
154
        self.assertTrue('  first post' in out)
228
155
        self.assertEqual('', err)
229
156
 
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
 
 
 
157
 
308
158
class TestLogEncodings(TestCaseInTempDir):
309
159
 
310
160
    _mu = u'\xb5'
338
188
        bzr = self.run_bzr
339
189
        bzr('init')
340
190
        open('a', 'wb').write('some stuff\n')
341
 
        bzr('add a')
342
 
        bzr(['commit', '-m', self._message])
 
191
        bzr('add', 'a')
 
192
        bzr('commit', '-m', self._message)
343
193
 
344
194
    def try_encoding(self, encoding, fail=False):
345
195
        bzr = self.run_bzr
386
236
 
387
237
        bzr('init')
388
238
        self.build_tree(['a'])
389
 
        bzr('add a')
390
 
        bzr(['commit', '-m', u'\u0422\u0435\u0441\u0442'])
 
239
        bzr('add', 'a')
 
240
        bzr('commit', '-m', u'\u0422\u0435\u0441\u0442')
391
241
        stdout, stderr = self.run_bzr('log', encoding='cp866')
392
242
 
393
243
        message = stdout.splitlines()[-1]
405
255
        # Make sure the cp1251 string is not found anywhere
406
256
        self.assertEquals(-1, stdout.find(test_in_cp1251))
407
257
 
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')