← 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: John Arbash Meinel
  • Date: 2006-10-11 00:23:23 UTC
  • mfrom: (2070 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2071.
  • Revision ID: john@arbash-meinel.com-20061011002323-82ba88c293d7caff
[merge] bzr.dev 2070

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
26
 
from bzrlib.tests.test_log import (
27
 
    normalize_log,
28
 
    )
 
25
from bzrlib.tests import TestCaseInTempDir
29
26
 
30
27
 
31
28
class TestLog(ExternalBase):
32
29
 
33
 
    def _prepare(self, path='.', format=None):
34
 
        tree = self.make_branch_and_tree(path, format=format)
35
 
        self.build_tree(
36
 
            [path + '/hello.txt', path + '/goodbye.txt', path + '/meep.txt'])
37
 
        tree.add('hello.txt')
38
 
        tree.commit(message='message1')
39
 
        tree.add('goodbye.txt')
40
 
        tree.commit(message='message2')
41
 
        tree.add('meep.txt')
42
 
        tree.commit(message='message3')
43
 
        self.full_log = self.run_bzr(["log", path])[0]
44
 
        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]
45
40
 
46
41
    def test_log_null_end_revspec(self):
47
42
        self._prepare()
52
47
        self.assertTrue('message:\n  message2\n' in self.full_log)
53
48
        self.assertTrue('message:\n  message3\n' in self.full_log)
54
49
 
55
 
        log = self.run_bzr("log -r 1..")[0]
56
 
        self.assertEqualDiff(log, self.full_log)
 
50
        log = self.runbzr("log -r 1..")[0]
 
51
        self.assertEquals(log, self.full_log)
57
52
 
58
53
    def test_log_null_begin_revspec(self):
59
54
        self._prepare()
60
 
        log = self.run_bzr("log -r ..3")[0]
61
 
        self.assertEqualDiff(self.full_log, log)
 
55
        log = self.runbzr("log -r ..3")[0]
 
56
        self.assertEquals(self.full_log, log)
62
57
 
63
58
    def test_log_null_both_revspecs(self):
64
59
        self._prepare()
65
 
        log = self.run_bzr("log -r ..")[0]
66
 
        self.assertEqualDiff(self.full_log, log)
67
 
 
68
 
    def test_log_zero_revspec(self):
69
 
        self._prepare()
70
 
        self.run_bzr_error('bzr: ERROR: Logging revision 0 is invalid.',
71
 
                           ['log', '-r0'])
72
 
 
73
 
    def test_log_zero_begin_revspec(self):
74
 
        self._prepare()
75
 
        self.run_bzr_error('bzr: ERROR: Logging revision 0 is invalid.',
76
 
                           ['log', '-r0..2'])
77
 
 
78
 
    def test_log_zero_end_revspec(self):
79
 
        self._prepare()
80
 
        self.run_bzr_error('bzr: ERROR: Logging revision 0 is invalid.',
81
 
                           ['log', '-r-2..0'])
82
 
 
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'])
 
60
        log = self.runbzr("log -r ..")[0]
 
61
        self.assertEquals(self.full_log, log)
88
62
 
89
63
    def test_log_negative_begin_revspec_full_log(self):
90
64
        self._prepare()
91
 
        log = self.run_bzr("log -r -3..")[0]
92
 
        self.assertEqualDiff(self.full_log, log)
 
65
        log = self.runbzr("log -r -3..")[0]
 
66
        self.assertEquals(self.full_log, log)
93
67
 
94
68
    def test_log_negative_both_revspec_full_log(self):
95
69
        self._prepare()
96
 
        log = self.run_bzr("log -r -3..-1")[0]
97
 
        self.assertEqualDiff(self.full_log, log)
 
70
        log = self.runbzr("log -r -3..-1")[0]
 
71
        self.assertEquals(self.full_log, log)
98
72
 
99
73
    def test_log_negative_both_revspec_partial(self):
100
74
        self._prepare()
101
 
        log = self.run_bzr("log -r -3..-2")[0]
 
75
        log = self.runbzr("log -r -3..-2")[0]
102
76
        self.assertTrue('revno: 1\n' in log)
103
77
        self.assertTrue('revno: 2\n' in log)
104
78
        self.assertTrue('revno: 3\n' not in log)
105
79
 
106
80
    def test_log_negative_begin_revspec(self):
107
81
        self._prepare()
108
 
        log = self.run_bzr("log -r -2..")[0]
 
82
        log = self.runbzr("log -r -2..")[0]
109
83
        self.assertTrue('revno: 1\n' not in log)
110
84
        self.assertTrue('revno: 2\n' in log)
111
85
        self.assertTrue('revno: 3\n' in log)
112
86
 
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)
117
 
 
118
 
    def test_log_reversed_revspecs(self):
119
 
        self._prepare()
120
 
        self.run_bzr_error(('bzr: ERROR: Start revision must be older than '
121
 
                            'the end revision.\n',),
122
 
                           ['log', '-r3..1'])
 
87
    def test_log_postive_revspecs(self):
 
88
        self._prepare()
 
89
        log = self.runbzr("log -r 1..3")[0]
 
90
        self.assertEquals(self.full_log, log)
123
91
 
124
92
    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",
 
93
        os.mkdir('branch1')
 
94
        os.chdir('branch1')
 
95
        self._prepare()
 
96
        os.chdir('..')
 
97
        os.mkdir('branch2')
 
98
        os.chdir('branch2')
 
99
        self._prepare()
 
100
        os.chdir('..')
 
101
        log = self.runbzr("log -r revno:2:branch1..revno:3:branch2",
128
102
                          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]
 
103
        log = self.runbzr("log -r revno:1:branch2..revno:3:branch2")[0]
 
104
        self.assertEquals(self.full_log, log)
 
105
        log = self.runbzr("log -r revno:1:branch2")[0]
132
106
        self.assertTrue('revno: 1\n' in log)
133
107
        self.assertTrue('revno: 2\n' not in log)
134
108
        self.assertTrue('branch nick: branch2\n' in log)
135
109
        self.assertTrue('branch nick: branch1\n' not in log)
136
110
        
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')
144
 
 
145
 
    def test_log_with_tags(self):
146
 
        tree = self._prepare(format='dirstate-tags')
147
 
        branch = tree.branch
148
 
        branch.tags.set_tag('tag1', branch.get_rev_id(1))
149
 
        branch.tags.set_tag('tag1.1', branch.get_rev_id(1))
150
 
        branch.tags.set_tag('tag3', branch.last_revision()) 
151
 
        
152
 
        log = self.run_bzr("log -r-1")[0]
153
 
        self.assertTrue('tags: tag3' in log)
154
 
 
155
 
        log = self.run_bzr("log -r1")[0]
156
 
        # I guess that we can't know the order of tags in the output
157
 
        # since dicts are unordered, need to check both possibilities
158
 
        self.assertContainsRe(log, r'tags: (tag1, tag1\.1|tag1\.1, tag1)')
159
 
 
160
 
    def test_merged_log_with_tags(self):
161
 
        branch1_tree = self._prepare(path='branch1', format='dirstate-tags')
162
 
        branch1 = branch1_tree.branch
163
 
        branch2_tree = branch1_tree.bzrdir.sprout('branch2').open_workingtree()
164
 
        branch1_tree.commit(message='foobar', allow_pointless=True)
165
 
        branch1.tags.set_tag('tag1', branch1.last_revision())
166
 
        os.chdir('branch2')
167
 
        self.run_bzr('merge ../branch1') # tags don't propagate otherwise
168
 
        branch2_tree.commit(message='merge branch 1')
169
 
        log = self.run_bzr("log -r-1")[0]
170
 
        self.assertContainsRe(log, r'    tags: tag1')
171
 
        log = self.run_bzr("log -r3.1.1")[0]
172
 
        self.assertContainsRe(log, r'tags: tag1')
173
 
 
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
111
 
188
112
class TestLogMerges(ExternalBase):
189
113
 
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')
203
 
 
204
114
    def test_merges_are_indented_by_level(self):
205
 
        self._prepare()
 
115
        self.build_tree(['parent/'])
 
116
        self.run_bzr('init', 'parent')
 
117
        self.run_bzr('commit', '-m', 'first post', '--unchanged', 'parent')
 
118
        self.run_bzr('branch', 'parent', 'child')
 
119
        self.run_bzr('commit', '-m', 'branch 1', '--unchanged', 'child')
 
120
        self.run_bzr('branch', 'child', 'smallerchild')
 
121
        self.run_bzr('commit', '-m', 'branch 2', '--unchanged', 'smallerchild')
 
122
        os.chdir('child')
 
123
        self.run_bzr('merge', '../smallerchild')
 
124
        self.run_bzr('commit', '-m', 'merge branch 2')
 
125
        os.chdir('../parent')
 
126
        self.run_bzr('merge', '../child')
 
127
        self.run_bzr('commit', '-m', 'merge branch 1')
206
128
        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
 
""")
246
 
 
247
 
    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
 
""")
268
 
 
269
 
    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
 
 
 
129
        # the log will look something like:
 
130
#        self.assertEqual("""\
 
131
#------------------------------------------------------------
 
132
#revno: 2
 
133
#committer: Robert Collins <foo@example.com>
 
134
#branch nick: parent
 
135
#timestamp: Tue 2006-03-28 22:31:40 +1100
 
136
#message:
 
137
#  merge branch 1
 
138
#    ------------------------------------------------------------
 
139
#    merged: foo@example.com-20060328113140-91f43cfb46dc2863
 
140
#    committer: Robert Collins <foo@example.com>
 
141
#    branch nick: child
 
142
#    timestamp: Tue 2006-03-28 22:31:40 +1100
 
143
#    message:
 
144
#      merge branch 2
 
145
#        ------------------------------------------------------------
 
146
#        merged: foo@example.com-20060328113140-1ba24f850a0ef573
 
147
#        committer: Robert Collins <foo@example.com>
 
148
#        branch nick: smallerchild
 
149
#        timestamp: Tue 2006-03-28 22:31:40 +1100
 
150
#        message:
 
151
#          branch 2
 
152
#    ------------------------------------------------------------
 
153
#    merged: foo@example.com-20060328113140-5749a4757a8ac792
 
154
#    committer: Robert Collins <foo@example.com>
 
155
#    branch nick: child
 
156
#    timestamp: Tue 2006-03-28 22:31:40 +1100
 
157
#    message:
 
158
#      branch 1
 
159
#------------------------------------------------------------
 
160
#revno: 1
 
161
#committer: Robert Collins <foo@example.com>
 
162
#branch nick: parent
 
163
#timestamp: Tue 2006-03-28 22:31:39 +1100
 
164
#message:
 
165
#  first post
 
166
#""", out)
 
167
        # but we dont have a nice pattern matcher hooked up yet, so:
 
168
        # we check for the indenting of the commit message:
 
169
        self.assertTrue('  merge branch 1' in out)
 
170
        self.assertTrue('      merge branch 2' in out)
 
171
        self.assertTrue('          branch 2' in out)
 
172
        self.assertTrue('      branch 1' in out)
 
173
        self.assertTrue('  first post' in out)
 
174
        self.assertEqual('', err)
 
175
 
 
176
 
309
177
class TestLogEncodings(TestCaseInTempDir):
310
178
 
311
179
    _mu = u'\xb5'
339
207
        bzr = self.run_bzr
340
208
        bzr('init')
341
209
        open('a', 'wb').write('some stuff\n')
342
 
        bzr('add a')
343
 
        bzr(['commit', '-m', self._message])
 
210
        bzr('add', 'a')
 
211
        bzr('commit', '-m', self._message)
344
212
 
345
213
    def try_encoding(self, encoding, fail=False):
346
214
        bzr = self.run_bzr
387
255
 
388
256
        bzr('init')
389
257
        self.build_tree(['a'])
390
 
        bzr('add a')
391
 
        bzr(['commit', '-m', u'\u0422\u0435\u0441\u0442'])
 
258
        bzr('add', 'a')
 
259
        bzr('commit', '-m', u'\u0422\u0435\u0441\u0442')
392
260
        stdout, stderr = self.run_bzr('log', encoding='cp866')
393
261
 
394
262
        message = stdout.splitlines()[-1]
406
274
        # Make sure the cp1251 string is not found anywhere
407
275
        self.assertEquals(-1, stdout.find(test_in_cp1251))
408
276
 
409
 
 
410
 
class TestLogFile(TestCaseWithTransport):
411
 
 
412
 
    def test_log_local_branch_file(self):
413
 
        """We should be able to log files in local treeless branches"""
414
 
        tree = self.make_branch_and_tree('tree')
415
 
        self.build_tree(['tree/file'])
416
 
        tree.add('file')
417
 
        tree.commit('revision 1')
418
 
        tree.bzrdir.destroy_workingtree()
419
 
        self.run_bzr('log tree/file')
420
 
 
421
 
    def test_log_file(self):
422
 
        """The log for a particular file should only list revs for that file"""
423
 
        tree = self.make_branch_and_tree('parent')
424
 
        self.build_tree(['parent/file1', 'parent/file2', 'parent/file3'])
425
 
        tree.add('file1')
426
 
        tree.commit('add file1')
427
 
        tree.add('file2')
428
 
        tree.commit('add file2')
429
 
        tree.add('file3')
430
 
        tree.commit('add file3')
431
 
        child_tree = tree.bzrdir.sprout('child').open_workingtree()
432
 
        self.build_tree_contents([('child/file2', 'hello')])
433
 
        child_tree.commit(message='branch 1')
434
 
        tree.merge_from_branch(child_tree.branch)
435
 
        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')