/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 breezy/tests/blackbox/test_log.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-07-14 19:47:11 UTC
  • mfrom: (7027.4.12 python3-blackbox)
  • Revision ID: breezy.the.bot@gmail.com-20180714194711-h73vd0gzphiab6vf
Change run_bzr to use StringIOWithEncoding for stderr and stdout on python 3.

Merged from https://code.launchpad.net/~jelmer/brz/python3-blackbox/+merge/349090

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_log.py
29
29
    osutils,
30
30
    tests,
31
31
    )
 
32
from breezy.sixish import PY3
32
33
from breezy.tests import (
33
34
    test_log,
34
35
    features,
93
94
        return self.log_catcher.revisions
94
95
 
95
96
    def assertLogRevnos(self, args, expected_revnos, working_dir='.',
96
 
                        out=b'', err=b''):
 
97
                        out='', err=''):
97
98
        actual_out, actual_err = self.run_bzr(['log'] + args,
98
99
                                              working_dir=working_dir)
99
100
        self.assertEqual(out, actual_out)
236
237
 
237
238
    def test_n0(self):
238
239
        self.assertLogRevnos(['-n0', '-r1.1.1..1.1.4'],
239
 
                             [b'1.1.4', b'4', b'1.1.3', b'1.1.2', b'3', b'1.1.1'])
 
240
                             ['1.1.4', '4', '1.1.3', '1.1.2', '3', '1.1.1'])
240
241
 
241
242
    def test_n0_forward(self):
242
243
        self.assertLogRevnos(['-n0', '-r1.1.1..1.1.4', '--forward'],
243
 
                             [b'3', b'1.1.1', b'4', b'1.1.2', b'1.1.3', b'1.1.4'])
 
244
                             ['3', '1.1.1', '4', '1.1.2', '1.1.3', '1.1.4'])
244
245
 
245
246
    def test_n1(self):
246
247
        # starting from 1.1.4 we follow the left-hand ancestry
247
248
        self.assertLogRevnos(['-n1', '-r1.1.1..1.1.4'],
248
 
                             [b'1.1.4', b'1.1.3', b'1.1.2', b'1.1.1'])
 
249
                             ['1.1.4', '1.1.3', '1.1.2', '1.1.1'])
249
250
 
250
251
    def test_n1_forward(self):
251
252
        self.assertLogRevnos(['-n1', '-r1.1.1..1.1.4', '--forward'],
252
 
                             [b'1.1.1', b'1.1.2', b'1.1.3', b'1.1.4'])
 
253
                             ['1.1.1', '1.1.2', '1.1.3', '1.1.4'])
253
254
 
254
255
    def test_fallback_when_end_rev_is_not_on_mainline(self):
255
256
        self.assertLogRevnos(['-n1', '-r1.1.1..5.1.1'],
256
257
                             # We don't get 1.1.1 because we say -n1
257
 
                             [b'5.1.1', b'5', b'4', b'3'])
 
258
                             ['5.1.1', '5', '4', '3'])
258
259
 
259
260
 
260
261
class Test_GenerateAllRevisions(TestLogWithLogCatcher):
344
345
 
345
346
    def test_log_zero_revspec(self):
346
347
        self.make_minimal_branch()
347
 
        self.run_bzr_error([b'brz: ERROR: Logging revision 0 is invalid.'],
 
348
        self.run_bzr_error(['brz: ERROR: Logging revision 0 is invalid.'],
348
349
                           ['log', '-r0'])
349
350
 
350
351
    def test_log_zero_begin_revspec(self):
351
352
        self.make_linear_branch()
352
 
        self.run_bzr_error([b'brz: ERROR: Logging revision 0 is invalid.'],
 
353
        self.run_bzr_error(['brz: ERROR: Logging revision 0 is invalid.'],
353
354
                           ['log', '-r0..2'])
354
355
 
355
356
    def test_log_zero_end_revspec(self):
356
357
        self.make_linear_branch()
357
 
        self.run_bzr_error([b'brz: ERROR: Logging revision 0 is invalid.'],
 
358
        self.run_bzr_error(['brz: ERROR: Logging revision 0 is invalid.'],
358
359
                           ['log', '-r-2..0'])
359
360
 
360
361
    def test_log_nonexistent_revno(self):
361
362
        self.make_minimal_branch()
362
 
        self.run_bzr_error([b"brz: ERROR: Requested revision: '1234' "
363
 
                            b"does not exist in branch:"],
 
363
        self.run_bzr_error(["brz: ERROR: Requested revision: '1234' "
 
364
                            "does not exist in branch:"],
364
365
                           ['log', '-r1234'])
365
366
 
366
367
    def test_log_nonexistent_dotted_revno(self):
367
368
        self.make_minimal_branch()
368
 
        self.run_bzr_error([b"brz: ERROR: Requested revision: '123.123' "
369
 
                            b"does not exist in branch:"],
 
369
        self.run_bzr_error(["brz: ERROR: Requested revision: '123.123' "
 
370
                            "does not exist in branch:"],
370
371
                           ['log',  '-r123.123'])
371
372
 
372
373
    def test_log_change_nonexistent_revno(self):
373
374
        self.make_minimal_branch()
374
 
        self.run_bzr_error([b"brz: ERROR: Requested revision: '1234' "
375
 
                            b"does not exist in branch:"],
 
375
        self.run_bzr_error(["brz: ERROR: Requested revision: '1234' "
 
376
                            "does not exist in branch:"],
376
377
                           ['log',  '-c1234'])
377
378
 
378
379
    def test_log_change_nonexistent_dotted_revno(self):
379
380
        self.make_minimal_branch()
380
 
        self.run_bzr_error([b"brz: ERROR: Requested revision: '123.123' "
381
 
                            b"does not exist in branch:"],
 
381
        self.run_bzr_error(["brz: ERROR: Requested revision: '123.123' "
 
382
                            "does not exist in branch:"],
382
383
                           ['log', '-c123.123'])
383
384
 
384
385
    def test_log_change_single_revno_only(self):
385
386
        self.make_minimal_branch()
386
 
        self.run_bzr_error([b'brz: ERROR: Option --change does not'
387
 
                           b' accept revision ranges'],
 
387
        self.run_bzr_error(['brz: ERROR: Option --change does not'
 
388
                            ' accept revision ranges'],
388
389
                           ['log', '--change', '2..3'])
389
390
 
390
391
    def test_log_change_incompatible_with_revision(self):
391
 
        self.run_bzr_error([b'brz: ERROR: --revision and --change'
392
 
                           b' are mutually exclusive'],
 
392
        self.run_bzr_error(['brz: ERROR: --revision and --change'
 
393
                            ' are mutually exclusive'],
393
394
                           ['log', '--change', '2', '--revision', '3'])
394
395
 
395
396
    def test_log_nonexistent_file(self):
398
399
        # should give an error
399
400
        out, err = self.run_bzr('log does-not-exist', retcode=3)
400
401
        self.assertContainsRe(err,
401
 
                              b'Path unknown at end or start of revision range: '
402
 
                              b'does-not-exist')
 
402
                              'Path unknown at end or start of revision range: '
 
403
                              'does-not-exist')
403
404
 
404
405
    def test_log_reversed_revspecs(self):
405
406
        self.make_linear_branch()
406
 
        self.run_bzr_error((b'brz: ERROR: Start revision must be older than '
407
 
                            b'the end revision.\n',),
 
407
        self.run_bzr_error(('brz: ERROR: Start revision must be older than '
 
408
                            'the end revision.\n',),
408
409
                           ['log', '-r3..1'])
409
410
 
410
411
    def test_log_reversed_dotted_revspecs(self):
411
412
        self.make_merged_branch()
412
 
        self.run_bzr_error((b'brz: ERROR: Start revision not found in '
413
 
                            b'history of end revision.\n',),
 
413
        self.run_bzr_error(('brz: ERROR: Start revision not found in '
 
414
                            'history of end revision.\n',),
414
415
                           "log -r 1.1.1..1")
415
416
 
416
417
    def test_log_bad_message_re(self):
420
421
        """
421
422
        self.make_minimal_branch()
422
423
        out, err = self.run_bzr(['log', '-m', '*'], retcode=3)
423
 
        self.assertContainsRe(err, b"ERROR.*Invalid pattern.*nothing to repeat")
424
 
        self.assertNotContainsRe(err, b"Unprintable exception")
425
 
        self.assertEqual(out, b'')
 
424
        self.assertContainsRe(err, "ERROR.*Invalid pattern.*nothing to repeat")
 
425
        self.assertNotContainsRe(err, "Unprintable exception")
 
426
        self.assertEqual(out, '')
426
427
 
427
428
    def test_log_unsupported_timezone(self):
428
429
        self.make_linear_branch()
429
 
        self.run_bzr_error([b'brz: ERROR: Unsupported timezone format "foo", '
430
 
                            b'options are "utc", "original", "local".'],
 
430
        self.run_bzr_error(['brz: ERROR: Unsupported timezone format "foo", '
 
431
                            'options are "utc", "original", "local".'],
431
432
                           ['log', '--timezone', 'foo'])
432
433
 
433
434
    def test_log_exclude_ancestry_no_range(self):
434
435
        self.make_linear_branch()
435
 
        self.run_bzr_error([b'brz: ERROR: --exclude-common-ancestry'
436
 
                            b' requires -r with two revisions'],
 
436
        self.run_bzr_error(['brz: ERROR: --exclude-common-ancestry'
 
437
                            ' requires -r with two revisions'],
437
438
                           ['log', '--exclude-common-ancestry'])
438
439
 
439
440
    def test_log_exclude_ancestry_single_revision(self):
440
441
        self.make_merged_branch()
441
 
        self.run_bzr_error([b'brz: ERROR: --exclude-common-ancestry'
442
 
                            b' requires two different revisions'],
 
442
        self.run_bzr_error(['brz: ERROR: --exclude-common-ancestry'
 
443
                            ' requires two different revisions'],
443
444
                           ['log', '--exclude-common-ancestry',
444
445
                            '-r1.1.1..1.1.1'])
445
446
 
471
472
        self.run_bzr('merge ../branch1', working_dir='branch2')
472
473
        branch2_tree.commit(message='merge branch 1')
473
474
        log = self.run_bzr("log -n0 -r-1", working_dir='branch2')[0]
474
 
        self.assertContainsRe(log, br'    tags: tag1')
 
475
        self.assertContainsRe(log, r'    tags: tag1')
475
476
        log = self.run_bzr("log -n0 -r3.1.1", working_dir='branch2')[0]
476
 
        self.assertContainsRe(log, br'tags: tag1')
 
477
        self.assertContainsRe(log, r'tags: tag1')
477
478
 
478
479
 
479
480
class TestLogSignatures(TestLog):
504
505
    def assertUseShortDeltaFormat(self, cmd):
505
506
        log = self.run_bzr(cmd)[0]
506
507
        # Check that we use the short status format
507
 
        self.assertContainsRe(log, b'(?m)^\\s*A  hello.txt$')
508
 
        self.assertNotContainsRe(log, b'(?m)^\\s*added:$')
 
508
        self.assertContainsRe(log, '(?m)^\\s*A  hello.txt$')
 
509
        self.assertNotContainsRe(log, '(?m)^\\s*added:$')
509
510
 
510
511
    def assertUseLongDeltaFormat(self, cmd):
511
512
        log = self.run_bzr(cmd)[0]
512
513
        # Check that we use the long status format
513
 
        self.assertNotContainsRe(log, b'(?m)^\\s*A  hello.txt$')
514
 
        self.assertContainsRe(log, b'(?m)^\\s*added:$')
 
514
        self.assertNotContainsRe(log, '(?m)^\\s*A  hello.txt$')
 
515
        self.assertContainsRe(log, '(?m)^\\s*added:$')
515
516
 
516
517
    def test_log_short_verbose(self):
517
518
        self.assertUseShortDeltaFormat(['log', '--short', '-v'])
721
722
        # check that command won't fail with unicode error
722
723
        # don't care about exact output because we have other tests for this
723
724
        out, err = self.run_bzr('log -p --long')
724
 
        self.assertNotEqual(b'', out)
725
 
        self.assertEqual(b'', err)
 
725
        self.assertNotEqual('', out)
 
726
        self.assertEqual('', err)
726
727
        out, err = self.run_bzr('log -p --short')
727
 
        self.assertNotEqual(b'', out)
728
 
        self.assertEqual(b'', err)
 
728
        self.assertNotEqual('', out)
 
729
        self.assertEqual('', err)
729
730
        out, err = self.run_bzr('log -p --line')
730
 
        self.assertNotEqual(b'', out)
731
 
        self.assertEqual(b'', err)
 
731
        self.assertNotEqual('', out)
 
732
        self.assertEqual('', err)
732
733
 
733
734
 
734
735
class TestLogEncodings(tests.TestCaseInTempDir):
782
783
            out, err = brz('log', encoding=encoding)
783
784
            if not fail:
784
785
                # Make sure we wrote mu as we expected it to exist
785
 
                self.assertNotEqual(-1, out.find(encoded_msg))
786
 
                out_unicode = out.decode(encoding)
 
786
                if not PY3:
 
787
                    self.assertNotEqual(-1, out.find(encoded_msg))
 
788
                    out_unicode = out.decode(encoding)
 
789
                else:
 
790
                    out_unicode = out
787
791
                self.assertNotEqual(-1, out_unicode.find(self._message))
788
792
            else:
789
793
                self.assertNotEqual(-1, out.find('Message with ?'))
988
992
    def setUp(self):
989
993
        super(MainlineGhostTests, self).setUp()
990
994
        tree = self.make_branch_and_tree('')
991
 
        tree.set_parent_ids(["spooky"], allow_leftmost_as_ghost=True)
 
995
        tree.set_parent_ids([b"spooky"], allow_leftmost_as_ghost=True)
992
996
        tree.add('')
993
997
        tree.commit('msg1', rev_id=b'rev1')
994
998
        tree.commit('msg2', rev_id=b'rev2')