/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_log.py

1st cut merge of bzr.dev r3907

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_log.py
20
20
 
21
21
import os
22
22
 
23
 
import bzrlib
 
23
from bzrlib import osutils
24
24
from bzrlib.tests.blackbox import ExternalBase
25
25
from bzrlib.tests import TestCaseInTempDir, TestCaseWithTransport
26
26
from bzrlib.tests.test_log import (
29
29
from bzrlib.tests import test_log
30
30
 
31
31
 
32
 
class TestCaseWithoutPropsHandler(ExternalBase, test_log.TestCaseWithoutPropsHandler):
 
32
class TestCaseWithoutPropsHandler(ExternalBase,
 
33
                                  test_log.TestCaseWithoutPropsHandler):
33
34
    pass
34
35
 
35
36
 
138
139
        self.assertTrue('revno: 2\n' not in log)
139
140
        self.assertTrue('branch nick: branch2\n' in log)
140
141
        self.assertTrue('branch nick: branch1\n' not in log)
141
 
        
 
142
 
 
143
    def test_log_nonexistent_revno(self):
 
144
        self._prepare()
 
145
        (out, err) = self.run_bzr_error(args="log -r 1234",
 
146
            error_regexes=["bzr: ERROR: Requested revision: '1234' "
 
147
                "does not exist in branch:"])
 
148
 
 
149
    def test_log_nonexistent_dotted_revno(self):
 
150
        self._prepare()
 
151
        (out, err) = self.run_bzr_error(args="log -r 123.123",
 
152
            error_regexes=["bzr: ERROR: Requested revision: '123.123' "
 
153
                "does not exist in branch:"])
 
154
 
 
155
    def test_log_change_revno(self):
 
156
        self._prepare()
 
157
        expected_log = self.run_bzr("log -r 1")[0]
 
158
        log = self.run_bzr("log -c 1")[0]
 
159
        self.assertEqualDiff(expected_log, log)
 
160
 
 
161
    def test_log_change_nonexistent_revno(self):
 
162
        self._prepare()
 
163
        (out, err) = self.run_bzr_error(args="log -c 1234",
 
164
            error_regexes=["bzr: ERROR: Requested revision: '1234' "
 
165
                "does not exist in branch:"])
 
166
 
 
167
    def test_log_change_nonexistent_dotted_revno(self):
 
168
        self._prepare()
 
169
        (out, err) = self.run_bzr_error(args="log -c 123.123",
 
170
            error_regexes=["bzr: ERROR: Requested revision: '123.123' "
 
171
                "does not exist in branch:"])
 
172
 
 
173
    def test_log_change_single_revno(self):
 
174
        self._prepare()
 
175
        self.run_bzr_error('bzr: ERROR: Option --change does not'
 
176
                           ' accept revision ranges',
 
177
                           ['log', '--change', '2..3'])
 
178
 
 
179
    def test_log_change_incompatible_with_revision(self):
 
180
        self._prepare()
 
181
        self.run_bzr_error('bzr: ERROR: --revision and --change'
 
182
                           ' are mutually exclusive',
 
183
                           ['log', '--change', '2', '--revision', '3'])
 
184
 
142
185
    def test_log_nonexistent_file(self):
143
186
        # files that don't exist in either the basis tree or working tree
144
187
        # should give an error
152
195
        branch = tree.branch
153
196
        branch.tags.set_tag('tag1', branch.get_rev_id(1))
154
197
        branch.tags.set_tag('tag1.1', branch.get_rev_id(1))
155
 
        branch.tags.set_tag('tag3', branch.last_revision()) 
156
 
        
 
198
        branch.tags.set_tag('tag3', branch.last_revision())
 
199
 
157
200
        log = self.run_bzr("log -r-1")[0]
158
201
        self.assertTrue('tags: tag3' in log)
159
202
 
177
220
        self.assertContainsRe(log, r'tags: tag1')
178
221
 
179
222
    def test_log_limit(self):
180
 
        self._prepare()
 
223
        tree = self.make_branch_and_tree('.')
 
224
        # We want more commits than our batch size starts at
 
225
        for pos in range(10):
 
226
            tree.commit("%s" % pos)
181
227
        log = self.run_bzr("log --limit 2")[0]
182
228
        self.assertNotContainsRe(log, r'revno: 1\n')
183
 
        self.assertContainsRe(log, r'revno: 2\n')
184
 
        self.assertContainsRe(log, r'revno: 3\n')
 
229
        self.assertNotContainsRe(log, r'revno: 2\n')
 
230
        self.assertNotContainsRe(log, r'revno: 3\n')
 
231
        self.assertNotContainsRe(log, r'revno: 4\n')
 
232
        self.assertNotContainsRe(log, r'revno: 5\n')
 
233
        self.assertNotContainsRe(log, r'revno: 6\n')
 
234
        self.assertNotContainsRe(log, r'revno: 7\n')
 
235
        self.assertNotContainsRe(log, r'revno: 8\n')
 
236
        self.assertContainsRe(log, r'revno: 9\n')
 
237
        self.assertContainsRe(log, r'revno: 10\n')
185
238
 
186
239
    def test_log_limit_short(self):
187
240
        self._prepare()
191
244
        self.assertContainsRe(log, r'revno: 3\n')
192
245
 
193
246
 
 
247
class TestLogVerbose(TestCaseWithTransport):
 
248
 
 
249
    def setUp(self):
 
250
        super(TestLogVerbose, self).setUp()
 
251
        tree = self.make_branch_and_tree('.')
 
252
        self.build_tree(['hello.txt'])
 
253
        tree.add('hello.txt')
 
254
        tree.commit(message='message1')
 
255
 
 
256
    def assertUseShortDeltaFormat(self, cmd):
 
257
        log = self.run_bzr(cmd)[0]
 
258
        # Check that we use the short status format
 
259
        self.assertContainsRe(log, '(?m)^A  hello.txt$')
 
260
        self.assertNotContainsRe(log, '(?m)^added:$')
 
261
 
 
262
    def assertUseLongDeltaFormat(self, cmd):
 
263
        log = self.run_bzr(cmd)[0]
 
264
        # Check that we use the long status format
 
265
        self.assertNotContainsRe(log, '(?m)^A  hello.txt$')
 
266
        self.assertContainsRe(log, '(?m)^added:$')
 
267
 
 
268
    def test_log_short_verbose(self):
 
269
        self.assertUseShortDeltaFormat(['log', '--short', '-v'])
 
270
 
 
271
    def test_log_short_verbose_verbose(self):
 
272
        self.assertUseLongDeltaFormat(['log', '--short', '-vv'])
 
273
 
 
274
    def test_log_long_verbose(self):
 
275
        # Check that we use the long status format, ignoring the verbosity
 
276
        # level
 
277
        self.assertUseLongDeltaFormat(['log', '--long', '-v'])
 
278
 
 
279
    def test_log_long_verbose_verbose(self):
 
280
        # Check that we use the long status format, ignoring the verbosity
 
281
        # level
 
282
        self.assertUseLongDeltaFormat(['log', '--long', '-vv'])
 
283
 
 
284
 
194
285
class TestLogMerges(TestCaseWithoutPropsHandler):
195
286
 
196
287
    def _prepare(self):
274
365
 
275
366
    def test_merges_partial_range(self):
276
367
        self._prepare()
277
 
        out,err = self.run_bzr('log -r1.1.1..1.1.2')
 
368
        out, err = self.run_bzr('log -r1.1.1..1.1.2')
278
369
        self.assertEqual('', err)
279
370
        log = normalize_log(out)
280
371
        self.assertEqualDiff(log, """\
311
402
        out,err = self.run_bzr('log --short -r1.1.1..1.1.2', retcode=3)
312
403
        self.assertContainsRe(err, err_msg)
313
404
 
314
 
 
 
405
 
315
406
class TestLogEncodings(TestCaseInTempDir):
316
407
 
317
408
    _mu = u'\xb5'
335
426
 
336
427
    def setUp(self):
337
428
        TestCaseInTempDir.setUp(self)
338
 
        self.user_encoding = bzrlib.user_encoding
 
429
        self.user_encoding = osutils._cached_user_encoding
339
430
 
340
431
    def tearDown(self):
341
 
        bzrlib.user_encoding = self.user_encoding
 
432
        osutils._cached_user_encoding = self.user_encoding
342
433
        TestCaseInTempDir.tearDown(self)
343
434
 
344
435
    def create_branch(self):
357
448
        else:
358
449
            encoded_msg = self._message.encode(encoding)
359
450
 
360
 
        old_encoding = bzrlib.user_encoding
 
451
        old_encoding = osutils._cached_user_encoding
361
452
        # This test requires that 'run_bzr' uses the current
362
453
        # bzrlib, because we override user_encoding, and expect
363
454
        # it to be used
364
455
        try:
365
 
            bzrlib.user_encoding = 'ascii'
 
456
            osutils._cached_user_encoding = 'ascii'
366
457
            # We should be able to handle any encoding
367
458
            out, err = bzr('log', encoding=encoding)
368
459
            if not fail:
373
464
            else:
374
465
                self.assertNotEqual(-1, out.find('Message with ?'))
375
466
        finally:
376
 
            bzrlib.user_encoding = old_encoding
 
467
            osutils._cached_user_encoding = old_encoding
377
468
 
378
469
    def test_log_handles_encoding(self):
379
470
        self.create_branch()
389
480
 
390
481
    def test_stdout_encoding(self):
391
482
        bzr = self.run_bzr
392
 
        bzrlib.user_encoding = "cp1251"
 
483
        osutils._cached_user_encoding = "cp1251"
393
484
 
394
485
        bzr('init')
395
486
        self.build_tree(['a'])