← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
17
17
"""Tests for the test framework."""
18
18
 
19
19
from cStringIO import StringIO
20
 
from doctest import ELLIPSIS
 
20
import doctest
21
21
import os
22
22
import signal
23
23
import sys
42
42
from bzrlib import (
43
43
    branchbuilder,
44
44
    bzrdir,
45
 
    debug,
46
45
    errors,
47
46
    lockdir,
48
47
    memorytree,
56
55
    )
57
56
from bzrlib.repofmt import (
58
57
    groupcompress_repo,
59
 
    pack_repo,
60
58
    )
61
59
from bzrlib.symbol_versioning import (
62
60
    deprecated_function,
67
65
    features,
68
66
    test_lsprof,
69
67
    test_server,
70
 
    test_sftp_transport,
71
68
    TestUtil,
72
69
    )
73
70
from bzrlib.trace import note, mutter
74
71
from bzrlib.transport import memory
75
 
from bzrlib.version import _get_bzr_source_tree
76
72
 
77
73
 
78
74
def _test_ids(test_suite):
91
87
            "text", "plain", {"charset": "utf8"})))
92
88
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
93
89
        self.assertThat(self.get_log(),
94
 
            DocTestMatches(u"...a test message\n", ELLIPSIS))
 
90
            DocTestMatches(u"...a test message\n", doctest.ELLIPSIS))
95
91
 
96
92
 
97
93
class TestUnicodeFilename(tests.TestCase):
3212
3208
        tpr.register('bar', 'bBB.aAA.rRR')
3213
3209
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
3214
3210
        self.assertThat(self.get_log(),
3215
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
 
3211
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
 
3212
                           doctest.ELLIPSIS))
3216
3213
 
3217
3214
    def test_get_unknown_prefix(self):
3218
3215
        tpr = self._get_registry()
3414
3411
 
3415
3412
class TestEnvironHandling(tests.TestCase):
3416
3413
 
3417
 
    def test__captureVar_None_called_twice_leaks(self):
3418
 
        self.failIf('MYVAR' in os.environ)
3419
 
        self._captureVar('MYVAR', '42')
3420
 
        # We need an embedded test to observe the bug
3421
 
        class Test(tests.TestCase):
3422
 
            def test_me(self):
3423
 
                # The first call save the 42 value
3424
 
                self._captureVar('MYVAR', None)
3425
 
                self.assertEquals(None, os.environ.get('MYVAR'))
3426
 
                self.assertEquals('42', self._old_env.get('MYVAR'))
3427
 
                # But the second one erases it !
3428
 
                self._captureVar('MYVAR', None)
3429
 
                self.assertEquals(None, self._old_env.get('MYVAR'))
3430
 
        output = StringIO()
3431
 
        result = tests.TextTestResult(output, 0, 1)
3432
 
        Test('test_me').run(result)
3433
 
        if not result.wasStrictlySuccessful():
3434
 
            self.fail(output.getvalue())
3435
 
        # And we have lost all trace of the original value
3436
 
        self.assertEquals(None, os.environ.get('MYVAR'))
3437
 
        self.assertEquals(None, self._old_env.get('MYVAR'))
3438
 
 
3439
3414
    def test_overrideEnv_None_called_twice_doesnt_leak(self):
3440
3415
        self.failIf('MYVAR' in os.environ)
3441
3416
        self.overrideEnv('MYVAR', '42')
3455
3430
            self.fail(output.getvalue())
3456
3431
        # We get our value back
3457
3432
        self.assertEquals('42', os.environ.get('MYVAR'))
 
3433
 
 
3434
 
 
3435
class TestIsolatedEnv(tests.TestCase):
 
3436
    """Test isolating tests from os.environ.
 
3437
 
 
3438
    Since we use tests that are already isolated from os.environ a bit of care
 
3439
    should be taken when designing the tests to avoid bootstrap side-effects.
 
3440
    The tests start an already clean os.environ which allow doing valid
 
3441
    assertions about which variables are present or not and design tests around
 
3442
    these assertions.
 
3443
    """
 
3444
 
 
3445
    class ScratchMonkey(tests.TestCase):
 
3446
 
 
3447
        def test_me(self):
 
3448
            pass
 
3449
 
 
3450
    def test_basics(self):
 
3451
        # Make sure we know the definition of BZR_HOME: not part of os.environ
 
3452
        # for tests.TestCase.
 
3453
        self.assertTrue('BZR_HOME' in tests.isolated_environ)
 
3454
        self.assertEquals(None, tests.isolated_environ['BZR_HOME'])
 
3455
        # Being part of isolated_environ, BZR_HOME should not appear here
 
3456
        self.assertFalse('BZR_HOME' in os.environ)
 
3457
        # Make sure we know the definition of LINES: part of os.environ for
 
3458
        # tests.TestCase
 
3459
        self.assertTrue('LINES' in tests.isolated_environ)
 
3460
        self.assertEquals('25', tests.isolated_environ['LINES'])
 
3461
        self.assertEquals('25', os.environ['LINES'])
 
3462
 
 
3463
    def test_injecting_unknown_variable(self):
 
3464
        # BZR_HOME is known to be absent from os.environ
 
3465
        test = self.ScratchMonkey('test_me')
 
3466
        tests.override_os_environ(test, {'BZR_HOME': 'foo'})
 
3467
        self.assertEquals('foo', os.environ['BZR_HOME'])
 
3468
        tests.restore_os_environ(test)
 
3469
        self.assertFalse('BZR_HOME' in os.environ)
 
3470
 
 
3471
    def test_injecting_known_variable(self):
 
3472
        test = self.ScratchMonkey('test_me')
 
3473
        # LINES is known to be present in os.environ
 
3474
        tests.override_os_environ(test, {'LINES': '42'})
 
3475
        self.assertEquals('42', os.environ['LINES'])
 
3476
        tests.restore_os_environ(test)
 
3477
        self.assertEquals('25', os.environ['LINES'])
 
3478
 
 
3479
    def test_deleting_variable(self):
 
3480
        test = self.ScratchMonkey('test_me')
 
3481
        # LINES is known to be present in os.environ
 
3482
        tests.override_os_environ(test, {'LINES': None})
 
3483
        self.assertTrue('LINES' not in os.environ)
 
3484
        tests.restore_os_environ(test)
 
3485
        self.assertEquals('25', os.environ['LINES'])
 
3486
 
 
3487
 
 
3488
class TestDocTestSuiteIsolation(tests.TestCase):
 
3489
    """Test that `tests.DocTestSuite` isolates doc tests from os.environ.
 
3490
 
 
3491
    Since tests.TestCase alreay provides an isolation from os.environ, we use
 
3492
    the clean environment as a base for testing. To precisely capture the
 
3493
    isolation provided by tests.DocTestSuite, we use doctest.DocTestSuite to
 
3494
    compare against.
 
3495
 
 
3496
    We want to make sure `tests.DocTestSuite` respect `tests.isolated_environ`,
 
3497
    not `os.environ` so each test overrides it to suit its needs.
 
3498
 
 
3499
    """
 
3500
 
 
3501
    def get_doctest_suite_for_string(self, klass, string):
 
3502
        class Finder(doctest.DocTestFinder):
 
3503
 
 
3504
            def find(*args, **kwargs):
 
3505
                test = doctest.DocTestParser().get_doctest(
 
3506
                    string, {}, 'foo', 'foo.py', 0)
 
3507
                return [test]
 
3508
 
 
3509
        suite = klass(test_finder=Finder())
 
3510
        return suite
 
3511
 
 
3512
    def run_doctest_suite_for_string(self, klass, string):
 
3513
        suite = self.get_doctest_suite_for_string(klass, string)
 
3514
        output = StringIO()
 
3515
        result = tests.TextTestResult(output, 0, 1)
 
3516
        suite.run(result)
 
3517
        return result, output
 
3518
 
 
3519
    def assertDocTestStringSucceds(self, klass, string):
 
3520
        result, output = self.run_doctest_suite_for_string(klass, string)
 
3521
        if not result.wasStrictlySuccessful():
 
3522
            self.fail(output.getvalue())
 
3523
 
 
3524
    def assertDocTestStringFails(self, klass, string):
 
3525
        result, output = self.run_doctest_suite_for_string(klass, string)
 
3526
        if result.wasStrictlySuccessful():
 
3527
            self.fail(output.getvalue())
 
3528
 
 
3529
    def test_injected_variable(self):
 
3530
        self.overrideAttr(tests, 'isolated_environ', {'LINES': '42'})
 
3531
        test = """
 
3532
            >>> import os
 
3533
            >>> os.environ['LINES']
 
3534
            '42'
 
3535
            """
 
3536
        # doctest.DocTestSuite fails as it sees '25'
 
3537
        self.assertDocTestStringFails(doctest.DocTestSuite, test)
 
3538
        # tests.DocTestSuite sees '42'
 
3539
        self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)
 
3540
 
 
3541
    def test_deleted_variable(self):
 
3542
        self.overrideAttr(tests, 'isolated_environ', {'LINES': None})
 
3543
        test = """
 
3544
            >>> import os
 
3545
            >>> os.environ.get('LINES')
 
3546
            """
 
3547
        # doctest.DocTestSuite fails as it sees '25'
 
3548
        self.assertDocTestStringFails(doctest.DocTestSuite, test)
 
3549
        # tests.DocTestSuite sees None
 
3550
        self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)