/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/test_osutils.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 19:09:26 UTC
  • mfrom: (6622.1.36 breezy)
  • Revision ID: jelmer@jelmer.uk-20170521190926-5vtz8xaf0e9ylrpc
Merge rename to breezy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_osutils.py
26
26
import tempfile
27
27
import time
28
28
 
29
 
from bzrlib import (
 
29
from breezy import (
30
30
    errors,
31
31
    lazy_regex,
32
32
    osutils,
35
35
    trace,
36
36
    win32utils,
37
37
    )
38
 
from bzrlib.tests import (
 
38
from breezy.tests import (
39
39
    features,
40
40
    file_utils,
41
41
    test__walkdirs_win32,
42
42
    )
43
 
from bzrlib.tests.scenarios import load_tests_apply_scenarios
 
43
from breezy.tests.scenarios import load_tests_apply_scenarios
44
44
 
45
45
 
46
46
class _UTF8DirReaderFeature(features.Feature):
47
47
 
48
48
    def _probe(self):
49
49
        try:
50
 
            from bzrlib import _readdir_pyx
 
50
            from breezy import _readdir_pyx
51
51
            self.reader = _readdir_pyx.UTF8DirReader
52
52
            return True
53
53
        except ImportError:
54
54
            return False
55
55
 
56
56
    def feature_name(self):
57
 
        return 'bzrlib._readdir_pyx'
 
57
        return 'breezy._readdir_pyx'
58
58
 
59
 
UTF8DirReaderFeature = features.ModuleAvailableFeature('bzrlib._readdir_pyx')
 
59
UTF8DirReaderFeature = features.ModuleAvailableFeature('breezy._readdir_pyx')
60
60
 
61
61
term_ios_feature = features.ModuleAvailableFeature('termios')
62
62
 
82
82
    # Some DirReaders are platform specific and even there they may not be
83
83
    # available.
84
84
    if UTF8DirReaderFeature.available():
85
 
        from bzrlib import _readdir_pyx
 
85
        from breezy import _readdir_pyx
86
86
        scenarios.append(('utf8',
87
87
                          dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
88
88
                               _native_to_unicode=_utf8_to_unicode)))
89
89
 
90
90
    if test__walkdirs_win32.win32_readdir_feature.available():
91
91
        try:
92
 
            from bzrlib import _walkdirs_win32
 
92
            from breezy import _walkdirs_win32
93
93
            scenarios.append(
94
94
                ('win32',
95
95
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
1117
1117
                         osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
1118
1118
 
1119
1119
    def test_osutils_binding(self):
1120
 
        from bzrlib.tests import test__chunks_to_lines
 
1120
        from breezy.tests import test__chunks_to_lines
1121
1121
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
1122
 
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
 
1122
            from breezy._chunks_to_lines_pyx import chunks_to_lines
1123
1123
        else:
1124
 
            from bzrlib._chunks_to_lines_py import chunks_to_lines
 
1124
            from breezy._chunks_to_lines_py import chunks_to_lines
1125
1125
        self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
1126
1126
 
1127
1127
 
1340
1340
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1341
1341
        self._save_platform_info()
1342
1342
        win32utils.winver = 'Windows NT'
1343
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1343
        from breezy._walkdirs_win32 import Win32ReadDir
1344
1344
        self.assertDirReaderIs(Win32ReadDir)
1345
1345
 
1346
1346
    def test_force_walkdirs_utf8_98(self):
1503
1503
    def test__walkdirs_utf8_win32readdir(self):
1504
1504
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1505
1505
        self.requireFeature(features.UnicodeFilenameFeature)
1506
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1506
        from breezy._walkdirs_win32 import Win32ReadDir
1507
1507
        self._save_platform_info()
1508
1508
        osutils._selected_dir_reader = Win32ReadDir()
1509
1509
        name0u = u'0file-\xb6'
1560
1560
        """make sure our Stat values are valid"""
1561
1561
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1562
1562
        self.requireFeature(features.UnicodeFilenameFeature)
1563
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1563
        from breezy._walkdirs_win32 import Win32ReadDir
1564
1564
        name0u = u'0file-\xb6'
1565
1565
        name0 = name0u.encode('utf8')
1566
1566
        self.build_tree([name0u])
1584
1584
        """make sure our Stat values are valid"""
1585
1585
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1586
1586
        self.requireFeature(features.UnicodeFilenameFeature)
1587
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1587
        from breezy._walkdirs_win32 import Win32ReadDir
1588
1588
        name0u = u'0dir-\u062c\u0648'
1589
1589
        name0 = name0u.encode('utf8')
1590
1590
        self.build_tree([name0u + '/'])
1731
1731
    def setUp(self):
1732
1732
        super(TestSetUnsetEnv, self).setUp()
1733
1733
 
1734
 
        self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
 
1734
        self.assertEqual(None, os.environ.get('BRZ_TEST_ENV_VAR'),
1735
1735
                         'Environment was not cleaned up properly.'
1736
 
                         ' Variable BZR_TEST_ENV_VAR should not exist.')
 
1736
                         ' Variable BRZ_TEST_ENV_VAR should not exist.')
1737
1737
        def cleanup():
1738
 
            if 'BZR_TEST_ENV_VAR' in os.environ:
1739
 
                del os.environ['BZR_TEST_ENV_VAR']
 
1738
            if 'BRZ_TEST_ENV_VAR' in os.environ:
 
1739
                del os.environ['BRZ_TEST_ENV_VAR']
1740
1740
        self.addCleanup(cleanup)
1741
1741
 
1742
1742
    def test_set(self):
1743
1743
        """Test that we can set an env variable"""
1744
 
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
 
1744
        old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'foo')
1745
1745
        self.assertEqual(None, old)
1746
 
        self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
 
1746
        self.assertEqual('foo', os.environ.get('BRZ_TEST_ENV_VAR'))
1747
1747
 
1748
1748
    def test_double_set(self):
1749
1749
        """Test that we get the old value out"""
1750
 
        osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1751
 
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
 
1750
        osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'foo')
 
1751
        old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'bar')
1752
1752
        self.assertEqual('foo', old)
1753
 
        self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
 
1753
        self.assertEqual('bar', os.environ.get('BRZ_TEST_ENV_VAR'))
1754
1754
 
1755
1755
    def test_unicode(self):
1756
1756
        """Environment can only contain plain strings
1763
1763
                'Cannot find a unicode character that works in encoding %s'
1764
1764
                % (osutils.get_user_encoding(),))
1765
1765
 
1766
 
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1767
 
        self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
 
1766
        old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', uni_val)
 
1767
        self.assertEqual(env_val, os.environ.get('BRZ_TEST_ENV_VAR'))
1768
1768
 
1769
1769
    def test_unset(self):
1770
1770
        """Test that passing None will remove the env var"""
1771
 
        osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1772
 
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
 
1771
        osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'foo')
 
1772
        old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', None)
1773
1773
        self.assertEqual('foo', old)
1774
 
        self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1775
 
        self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
 
1774
        self.assertEqual(None, os.environ.get('BRZ_TEST_ENV_VAR'))
 
1775
        self.assertFalse('BRZ_TEST_ENV_VAR' in os.environ)
1776
1776
 
1777
1777
 
1778
1778
class TestSizeShaFile(tests.TestCaseInTempDir):
1814
1814
class TestResourceLoading(tests.TestCaseInTempDir):
1815
1815
 
1816
1816
    def test_resource_string(self):
1817
 
        # test resource in bzrlib
1818
 
        text = osutils.resource_string('bzrlib', 'debug.py')
 
1817
        # test resource in breezy
 
1818
        text = osutils.resource_string('breezy', 'debug.py')
1819
1819
        self.assertContainsRe(text, "debug_flags = set()")
1820
 
        # test resource under bzrlib
1821
 
        text = osutils.resource_string('bzrlib.ui', 'text.py')
 
1820
        # test resource under breezy
 
1821
        text = osutils.resource_string('breezy.ui', 'text.py')
1822
1822
        self.assertContainsRe(text, "class TextUIFactory")
1823
1823
        # test unsupported package
1824
1824
        self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1825
1825
            'yyy.xx')
1826
1826
        # test unknown resource
1827
 
        self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
 
1827
        self.assertRaises(IOError, osutils.resource_string, 'breezy', 'yyy.xx')
1828
1828
 
1829
1829
 
1830
1830
class TestReCompile(tests.TestCase):
2021
2021
        self.assertIsInstance(concurrency, int)
2022
2022
 
2023
2023
    def test_local_concurrency_environment_variable(self):
2024
 
        self.overrideEnv('BZR_CONCURRENCY', '2')
 
2024
        self.overrideEnv('BRZ_CONCURRENCY', '2')
2025
2025
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
2026
 
        self.overrideEnv('BZR_CONCURRENCY', '3')
 
2026
        self.overrideEnv('BRZ_CONCURRENCY', '3')
2027
2027
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
2028
 
        self.overrideEnv('BZR_CONCURRENCY', 'foo')
 
2028
        self.overrideEnv('BRZ_CONCURRENCY', 'foo')
2029
2029
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
2030
2030
 
2031
2031
    def test_option_concurrency(self):
2032
 
        self.overrideEnv('BZR_CONCURRENCY', '1')
 
2032
        self.overrideEnv('BRZ_CONCURRENCY', '1')
2033
2033
        self.run_bzr('rocks --concurrency 42')
2034
2034
        # Command line overrides environment variable
2035
 
        self.assertEqual('42', os.environ['BZR_CONCURRENCY'])
 
2035
        self.assertEqual('42', os.environ['BRZ_CONCURRENCY'])
2036
2036
        self.assertEqual(42, osutils.local_concurrency(use_cache=False))
2037
2037
 
2038
2038
 
2040
2040
 
2041
2041
    def _try_loading(self):
2042
2042
        try:
2043
 
            import bzrlib._fictional_extension_py
 
2043
            import breezy._fictional_extension_py
2044
2044
        except ImportError, e:
2045
2045
            osutils.failed_to_load_extension(e)
2046
2046
            return True
2068
2068
        osutils.report_extension_load_failures()
2069
2069
        self.assertContainsRe(
2070
2070
            log.getvalue(),
2071
 
            r"bzr: warning: some compiled extensions could not be loaded; "
 
2071
            r"brz: warning: some compiled extensions could not be loaded; "
2072
2072
            "see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
2073
2073
            )
2074
2074
 
2104
2104
    def test_default_values(self):
2105
2105
        self.assertEqual(80, osutils.default_terminal_width)
2106
2106
 
2107
 
    def test_defaults_to_BZR_COLUMNS(self):
2108
 
        # BZR_COLUMNS is set by the test framework
2109
 
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
2110
 
        self.overrideEnv('BZR_COLUMNS', '12')
 
2107
    def test_defaults_to_BRZ_COLUMNS(self):
 
2108
        # BRZ_COLUMNS is set by the test framework
 
2109
        self.assertNotEqual('12', os.environ['BRZ_COLUMNS'])
 
2110
        self.overrideEnv('BRZ_COLUMNS', '12')
2111
2111
        self.assertEqual(12, osutils.terminal_width())
2112
2112
 
2113
 
    def test_BZR_COLUMNS_0_no_limit(self):
2114
 
        self.overrideEnv('BZR_COLUMNS', '0')
 
2113
    def test_BRZ_COLUMNS_0_no_limit(self):
 
2114
        self.overrideEnv('BRZ_COLUMNS', '0')
2115
2115
        self.assertEqual(None, osutils.terminal_width())
2116
2116
 
2117
2117
    def test_falls_back_to_COLUMNS(self):
2118
 
        self.overrideEnv('BZR_COLUMNS', None)
 
2118
        self.overrideEnv('BRZ_COLUMNS', None)
2119
2119
        self.assertNotEqual('42', os.environ['COLUMNS'])
2120
2120
        self.set_fake_tty()
2121
2121
        self.overrideEnv('COLUMNS', '42')
2122
2122
        self.assertEqual(42, osutils.terminal_width())
2123
2123
 
2124
2124
    def test_tty_default_without_columns(self):
2125
 
        self.overrideEnv('BZR_COLUMNS', None)
 
2125
        self.overrideEnv('BRZ_COLUMNS', None)
2126
2126
        self.overrideEnv('COLUMNS', None)
2127
2127
 
2128
2128
        def terminal_size(w, h):
2136
2136
        self.assertEqual(42, osutils.terminal_width())
2137
2137
 
2138
2138
    def test_non_tty_default_without_columns(self):
2139
 
        self.overrideEnv('BZR_COLUMNS', None)
 
2139
        self.overrideEnv('BRZ_COLUMNS', None)
2140
2140
        self.overrideEnv('COLUMNS', None)
2141
2141
        self.replace_stdout(None)
2142
2142
        self.assertEqual(None, osutils.terminal_width())
2153
2153
        else:
2154
2154
            self.overrideAttr(termios, 'TIOCGWINSZ')
2155
2155
            del termios.TIOCGWINSZ
2156
 
        self.overrideEnv('BZR_COLUMNS', None)
 
2156
        self.overrideEnv('BRZ_COLUMNS', None)
2157
2157
        self.overrideEnv('COLUMNS', None)
2158
2158
        # Whatever the result is, if we don't raise an exception, it's ok.
2159
2159
        osutils.terminal_width()
2198
2198
class TestPathFromEnviron(tests.TestCase):
2199
2199
 
2200
2200
    def test_is_unicode(self):
2201
 
        self.overrideEnv('BZR_TEST_PATH', './anywhere at all/')
2202
 
        path = osutils.path_from_environ('BZR_TEST_PATH')
 
2201
        self.overrideEnv('BRZ_TEST_PATH', './anywhere at all/')
 
2202
        path = osutils.path_from_environ('BRZ_TEST_PATH')
2203
2203
        self.assertIsInstance(path, unicode)
2204
2204
        self.assertEqual(u'./anywhere at all/', path)
2205
2205
 
2206
2206
    def test_posix_path_env_ascii(self):
2207
 
        self.overrideEnv('BZR_TEST_PATH', '/tmp')
2208
 
        home = osutils._posix_path_from_environ('BZR_TEST_PATH')
 
2207
        self.overrideEnv('BRZ_TEST_PATH', '/tmp')
 
2208
        home = osutils._posix_path_from_environ('BRZ_TEST_PATH')
2209
2209
        self.assertIsInstance(home, unicode)
2210
2210
        self.assertEqual(u'/tmp', home)
2211
2211
 
2212
2212
    def test_posix_path_env_unicode(self):
2213
2213
        self.requireFeature(features.ByteStringNamedFilesystem)
2214
 
        self.overrideEnv('BZR_TEST_PATH', '/home/\xa7test')
 
2214
        self.overrideEnv('BRZ_TEST_PATH', '/home/\xa7test')
2215
2215
        self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
2216
2216
        self.assertEqual(u'/home/\xa7test',
2217
 
            osutils._posix_path_from_environ('BZR_TEST_PATH'))
 
2217
            osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2218
2218
        osutils._fs_enc = "iso8859-5"
2219
2219
        self.assertEqual(u'/home/\u0407test',
2220
 
            osutils._posix_path_from_environ('BZR_TEST_PATH'))
 
2220
            osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2221
2221
        osutils._fs_enc = "utf-8"
2222
2222
        self.assertRaises(errors.BadFilenameEncoding,
2223
 
            osutils._posix_path_from_environ, 'BZR_TEST_PATH')
 
2223
            osutils._posix_path_from_environ, 'BRZ_TEST_PATH')
2224
2224
 
2225
2225
 
2226
2226
class TestGetHomeDir(tests.TestCase):