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

terminal_width can now returns None.

* bzrlib/win32utils.py:
(get_console_size): Fix typo in comment.

* bzrlib/ui/text.py:
(TextProgressView._show_line): Handle the no terminal present case.

* bzrlib/tests/test_osutils.py:
(TestTerminalWidth): Update tests.

* bzrlib/tests/blackbox/test_too_much.py:
Fix some imports.
(OldTests.test_bzr): Handle the no terminal present case.

* bzrlib/tests/__init__.py:
(VerboseTestResult.report_test_start): Handle the no terminal
present case.

* bzrlib/status.py:
(show_pending_merges): Handle the no terminal present case.
(show_pending_merges.show_log_message): Factor out some
code. Handle the no terminal present case.

* bzrlib/osutils.py:
(terminal_width): Return None if no precise value can be found.

* bzrlib/log.py:
(LineLogFormatter.__init__): Handle the no terminal present case.
(LineLogFormatter.truncate): Accept None as max_len meaning no
truncation.
(LineLogFormatter.log_string): 

* bzrlib/help.py:
(_help_commands_to_text): Handle the no terminal present case.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
23
23
import socket
24
24
import stat
25
25
import sys
 
26
import termios
26
27
import time
27
28
 
28
29
from bzrlib import (
33
34
    win32utils,
34
35
    )
35
36
from bzrlib.tests import (
36
 
    features,
37
37
    file_utils,
38
38
    test__walkdirs_win32,
39
39
    )
54
54
 
55
55
UTF8DirReaderFeature = _UTF8DirReaderFeature()
56
56
 
57
 
term_ios_feature = tests.ModuleAvailableFeature('termios')
58
 
 
59
57
 
60
58
def _already_unicode(s):
61
59
    return s
62
60
 
63
61
 
 
62
def _fs_enc_to_unicode(s):
 
63
    return s.decode(osutils._fs_enc)
 
64
 
 
65
 
64
66
def _utf8_to_unicode(s):
65
67
    return s.decode('UTF-8')
66
68
 
83
85
                          dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
84
86
                               _native_to_unicode=_utf8_to_unicode)))
85
87
 
86
 
    if test__walkdirs_win32.win32_readdir_feature.available():
 
88
    if test__walkdirs_win32.Win32ReadDirFeature.available():
87
89
        try:
88
90
            from bzrlib import _walkdirs_win32
 
91
            # TODO: check on windows, it may be that we need to use/add
 
92
            # safe_unicode instead of _fs_enc_to_unicode
89
93
            scenarios.append(
90
94
                ('win32',
91
95
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
92
 
                      _native_to_unicode=_already_unicode)))
 
96
                      _native_to_unicode=_fs_enc_to_unicode)))
93
97
        except ImportError:
94
98
            pass
95
99
    return scenarios
123
127
 
124
128
class TestRename(tests.TestCaseInTempDir):
125
129
 
126
 
    def create_file(self, filename, content):
127
 
        f = open(filename, 'wb')
128
 
        try:
129
 
            f.write(content)
130
 
        finally:
131
 
            f.close()
132
 
 
133
 
    def _fancy_rename(self, a, b):
134
 
        osutils.fancy_rename(a, b, rename_func=os.rename,
135
 
                             unlink_func=os.unlink)
136
 
 
137
130
    def test_fancy_rename(self):
138
131
        # This should work everywhere
139
 
        self.create_file('a', 'something in a\n')
140
 
        self._fancy_rename('a', 'b')
 
132
        def rename(a, b):
 
133
            osutils.fancy_rename(a, b,
 
134
                    rename_func=os.rename,
 
135
                    unlink_func=os.unlink)
 
136
 
 
137
        open('a', 'wb').write('something in a\n')
 
138
        rename('a', 'b')
141
139
        self.failIfExists('a')
142
140
        self.failUnlessExists('b')
143
141
        self.check_file_contents('b', 'something in a\n')
144
142
 
145
 
        self.create_file('a', 'new something in a\n')
146
 
        self._fancy_rename('b', 'a')
 
143
        open('a', 'wb').write('new something in a\n')
 
144
        rename('b', 'a')
147
145
 
148
146
        self.check_file_contents('a', 'something in a\n')
149
147
 
150
 
    def test_fancy_rename_fails_source_missing(self):
151
 
        # An exception should be raised, and the target should be left in place
152
 
        self.create_file('target', 'data in target\n')
153
 
        self.assertRaises((IOError, OSError), self._fancy_rename,
154
 
                          'missingsource', 'target')
155
 
        self.failUnlessExists('target')
156
 
        self.check_file_contents('target', 'data in target\n')
157
 
 
158
 
    def test_fancy_rename_fails_if_source_and_target_missing(self):
159
 
        self.assertRaises((IOError, OSError), self._fancy_rename,
160
 
                          'missingsource', 'missingtarget')
161
 
 
162
148
    def test_rename(self):
163
149
        # Rename should be semi-atomic on all platforms
164
 
        self.create_file('a', 'something in a\n')
 
150
        open('a', 'wb').write('something in a\n')
165
151
        osutils.rename('a', 'b')
166
152
        self.failIfExists('a')
167
153
        self.failUnlessExists('b')
168
154
        self.check_file_contents('b', 'something in a\n')
169
155
 
170
 
        self.create_file('a', 'new something in a\n')
 
156
        open('a', 'wb').write('new something in a\n')
171
157
        osutils.rename('b', 'a')
172
158
 
173
159
        self.check_file_contents('a', 'something in a\n')
184
170
        shape = sorted(os.listdir('.'))
185
171
        self.assertEquals(['A', 'B'], shape)
186
172
 
187
 
    def test_rename_error(self):
188
 
        # We wrap os.rename to make it give an error including the filenames
189
 
        # https://bugs.launchpad.net/bzr/+bug/491763
190
 
        err = self.assertRaises(OSError, osutils.rename,
191
 
            'nonexistent', 'target')
192
 
        self.assertContainsString(str(err), 'nonexistent')
193
 
 
194
173
 
195
174
class TestRandChars(tests.TestCase):
196
175
 
317
296
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
318
297
        self.assertEqual("@", osutils.kind_marker("symlink"))
319
298
        self.assertEqual("+", osutils.kind_marker("tree-reference"))
320
 
        self.assertEqual("", osutils.kind_marker("fifo"))
321
 
        self.assertEqual("", osutils.kind_marker("socket"))
322
 
        self.assertEqual("", osutils.kind_marker("unknown"))
 
299
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
323
300
 
324
301
 
325
302
class TestUmask(tests.TestCaseInTempDir):
390
367
        # Instead blackbox.test_locale should check for localized
391
368
        # dates once they do occur in output strings.
392
369
 
393
 
    def test_format_date_with_offset_in_original_timezone(self):
394
 
        self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
395
 
            osutils.format_date_with_offset_in_original_timezone(0))
396
 
        self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
397
 
            osutils.format_date_with_offset_in_original_timezone(100000))
398
 
        self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
399
 
            osutils.format_date_with_offset_in_original_timezone(100000, 7200))
400
 
 
401
370
    def test_local_time_offset(self):
402
371
        """Test that local_time_offset() returns a sane value."""
403
372
        offset = osutils.local_time_offset()
999
968
 
1000
969
    def test_osutils_binding(self):
1001
970
        from bzrlib.tests import test__chunks_to_lines
1002
 
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
 
971
        if test__chunks_to_lines.CompiledChunksToLinesFeature.available():
1003
972
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1004
973
        else:
1005
974
            from bzrlib._chunks_to_lines_py import chunks_to_lines
1145
1114
            dirblock[:] = new_dirblock
1146
1115
 
1147
1116
    def _save_platform_info(self):
1148
 
        self.overrideAttr(win32utils, 'winver')
1149
 
        self.overrideAttr(osutils, '_fs_enc')
1150
 
        self.overrideAttr(osutils, '_selected_dir_reader')
 
1117
        cur_winver = win32utils.winver
 
1118
        cur_fs_enc = osutils._fs_enc
 
1119
        cur_dir_reader = osutils._selected_dir_reader
 
1120
        def restore():
 
1121
            win32utils.winver = cur_winver
 
1122
            osutils._fs_enc = cur_fs_enc
 
1123
            osutils._selected_dir_reader = cur_dir_reader
 
1124
        self.addCleanup(restore)
1151
1125
 
1152
1126
    def assertDirReaderIs(self, expected):
1153
1127
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
1186
1160
 
1187
1161
    def test_force_walkdirs_utf8_nt(self):
1188
1162
        # Disabled because the thunk of the whole walkdirs api is disabled.
1189
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1163
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1190
1164
        self._save_platform_info()
1191
1165
        win32utils.winver = 'Windows NT'
1192
1166
        from bzrlib._walkdirs_win32 import Win32ReadDir
1193
1167
        self.assertDirReaderIs(Win32ReadDir)
1194
1168
 
1195
1169
    def test_force_walkdirs_utf8_98(self):
1196
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1170
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1197
1171
        self._save_platform_info()
1198
1172
        win32utils.winver = 'Windows 98'
1199
1173
        self.assertDirReaderIs(osutils.UnicodeDirReader)
1350
1324
        self.assertEqual(expected_dirblocks, result)
1351
1325
 
1352
1326
    def test__walkdirs_utf8_win32readdir(self):
1353
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1327
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1354
1328
        self.requireFeature(tests.UnicodeFilenameFeature)
1355
1329
        from bzrlib._walkdirs_win32 import Win32ReadDir
1356
1330
        self._save_platform_info()
1407
1381
 
1408
1382
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1409
1383
        """make sure our Stat values are valid"""
1410
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1384
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1411
1385
        self.requireFeature(tests.UnicodeFilenameFeature)
1412
1386
        from bzrlib._walkdirs_win32 import Win32ReadDir
1413
1387
        name0u = u'0file-\xb6'
1431
1405
 
1432
1406
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1433
1407
        """make sure our Stat values are valid"""
1434
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1408
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1435
1409
        self.requireFeature(tests.UnicodeFilenameFeature)
1436
1410
        from bzrlib._walkdirs_win32 import Win32ReadDir
1437
1411
        name0u = u'0dir-\u062c\u0648'
1586
1560
        def cleanup():
1587
1561
            if 'BZR_TEST_ENV_VAR' in os.environ:
1588
1562
                del os.environ['BZR_TEST_ENV_VAR']
 
1563
 
1589
1564
        self.addCleanup(cleanup)
1590
1565
 
1591
1566
    def test_set(self):
1639
1614
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
1640
1615
        self.build_tree_contents([('foo', text)])
1641
1616
        expected_sha = osutils.sha_string(text)
1642
 
        f = open('foo', 'rb')
 
1617
        f = open('foo')
1643
1618
        self.addCleanup(f.close)
1644
1619
        size, sha = osutils.size_sha_file(f)
1645
1620
        self.assertEqual(38, size)
1702
1677
 
1703
1678
    def setUp(self):
1704
1679
        tests.TestCaseInTempDir.setUp(self)
1705
 
        self.overrideAttr(osutils,
1706
 
                          '_selected_dir_reader', self._dir_reader_class())
 
1680
 
 
1681
        # Save platform specific info and reset it
 
1682
        cur_dir_reader = osutils._selected_dir_reader
 
1683
 
 
1684
        def restore():
 
1685
            osutils._selected_dir_reader = cur_dir_reader
 
1686
        self.addCleanup(restore)
 
1687
 
 
1688
        osutils._selected_dir_reader = self._dir_reader_class()
1707
1689
 
1708
1690
    def _get_ascii_tree(self):
1709
1691
        tree = [
1854
1836
 
1855
1837
class TestConcurrency(tests.TestCase):
1856
1838
 
1857
 
    def setUp(self):
1858
 
        super(TestConcurrency, self).setUp()
1859
 
        self.overrideAttr(osutils, '_cached_local_concurrency')
1860
 
 
1861
1839
    def test_local_concurrency(self):
1862
1840
        concurrency = osutils.local_concurrency()
1863
1841
        self.assertIsInstance(concurrency, int)
1864
1842
 
1865
 
    def test_local_concurrency_environment_variable(self):
1866
 
        os.environ['BZR_CONCURRENCY'] = '2'
1867
 
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1868
 
        os.environ['BZR_CONCURRENCY'] = '3'
1869
 
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1870
 
        os.environ['BZR_CONCURRENCY'] = 'foo'
1871
 
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1872
 
 
1873
 
    def test_option_concurrency(self):
1874
 
        os.environ['BZR_CONCURRENCY'] = '1'
1875
 
        self.run_bzr('rocks --concurrency 42')
1876
 
        # Command line overrides envrionment variable
1877
 
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1878
 
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1879
 
 
1880
1843
 
1881
1844
class TestFailedToLoadExtension(tests.TestCase):
1882
1845
 
1889
1852
 
1890
1853
    def setUp(self):
1891
1854
        super(TestFailedToLoadExtension, self).setUp()
1892
 
        self.overrideAttr(osutils, '_extension_load_failures', [])
 
1855
        self.saved_failures = osutils._extension_load_failures[:]
 
1856
        del osutils._extension_load_failures[:]
 
1857
        self.addCleanup(self.restore_failures)
 
1858
 
 
1859
    def restore_failures(self):
 
1860
        osutils._extension_load_failures = self.saved_failures
1893
1861
 
1894
1862
    def test_failure_to_load(self):
1895
1863
        self._try_loading()
1917
1885
 
1918
1886
class TestTerminalWidth(tests.TestCase):
1919
1887
 
1920
 
    def replace_stdout(self, new):
1921
 
        self.overrideAttr(sys, 'stdout', new)
1922
 
 
1923
 
    def replace__terminal_size(self, new):
1924
 
        self.overrideAttr(osutils, '_terminal_size', new)
1925
 
 
1926
 
    def set_fake_tty(self):
 
1888
    def test_default_values(self):
 
1889
        self.assertEquals(80, osutils.default_terminal_width)
 
1890
 
 
1891
    def test_defaults_to_COLUMNS(self):
 
1892
        # COLUMNS is set by the test framework
 
1893
        self.assertEquals('80', os.environ['COLUMNS'])
 
1894
        os.environ['COLUMNS'] = '12'
 
1895
        self.assertEquals(12, osutils.terminal_width())
 
1896
 
 
1897
    def test_tty_default_without_columns(self):
 
1898
        del os.environ['COLUMNS']
 
1899
        orig_stdout = sys.stdout
 
1900
        def restore():
 
1901
            sys.stdout = orig_stdout
 
1902
        self.addCleanup(restore)
1927
1903
 
1928
1904
        class I_am_a_tty(object):
1929
1905
            def isatty(self):
1930
1906
                return True
1931
1907
 
1932
 
        self.replace_stdout(I_am_a_tty())
1933
 
 
1934
 
    def test_default_values(self):
1935
 
        self.assertEqual(80, osutils.default_terminal_width)
1936
 
 
1937
 
    def test_defaults_to_BZR_COLUMNS(self):
1938
 
        # BZR_COLUMNS is set by the test framework
1939
 
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
1940
 
        os.environ['BZR_COLUMNS'] = '12'
1941
 
        self.assertEqual(12, osutils.terminal_width())
1942
 
 
1943
 
    def test_falls_back_to_COLUMNS(self):
1944
 
        del os.environ['BZR_COLUMNS']
1945
 
        self.assertNotEqual('42', os.environ['COLUMNS'])
1946
 
        self.set_fake_tty()
1947
 
        os.environ['COLUMNS'] = '42'
1948
 
        self.assertEqual(42, osutils.terminal_width())
1949
 
 
1950
 
    def test_tty_default_without_columns(self):
1951
 
        del os.environ['BZR_COLUMNS']
1952
 
        del os.environ['COLUMNS']
1953
 
 
1954
 
        def terminal_size(w, h):
1955
 
            return 42, 42
1956
 
 
1957
 
        self.set_fake_tty()
1958
 
        # We need to override the osutils definition as it depends on the
1959
 
        # running environment that we can't control (PQM running without a
1960
 
        # controlling terminal is one example).
1961
 
        self.replace__terminal_size(terminal_size)
1962
 
        self.assertEqual(42, osutils.terminal_width())
 
1908
        sys.stdout = I_am_a_tty()
 
1909
        self.assertEquals(None, osutils.terminal_width())
1963
1910
 
1964
1911
    def test_non_tty_default_without_columns(self):
1965
 
        del os.environ['BZR_COLUMNS']
1966
1912
        del os.environ['COLUMNS']
1967
 
        self.replace_stdout(None)
1968
 
        self.assertEqual(None, osutils.terminal_width())
 
1913
        orig_stdout = sys.stdout
 
1914
        def restore():
 
1915
            sys.stdout = orig_stdout
 
1916
        self.addCleanup(restore)
 
1917
        sys.stdout = None
 
1918
        self.assertEquals(None, osutils.terminal_width())
1969
1919
 
1970
 
    def test_no_TIOCGWINSZ(self):
1971
 
        self.requireFeature(term_ios_feature)
1972
 
        termios = term_ios_feature.module
 
1920
    def test_TIOCGWINSZ(self):
1973
1921
        # bug 63539 is about a termios without TIOCGWINSZ attribute
 
1922
        exist = True
1974
1923
        try:
1975
1924
            orig = termios.TIOCGWINSZ
1976
1925
        except AttributeError:
1977
 
            # We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
1978
 
            pass
1979
 
        else:
1980
 
            self.overrideAttr(termios, 'TIOCGWINSZ')
1981
 
            del termios.TIOCGWINSZ
1982
 
        del os.environ['BZR_COLUMNS']
 
1926
            exist = False
 
1927
 
 
1928
        def restore():
 
1929
            if exist:
 
1930
                termios.TIOCGWINSZ = orig
 
1931
        self.addCleanup(restore)
 
1932
 
 
1933
        del termios.TIOCGWINSZ
1983
1934
        del os.environ['COLUMNS']
1984
 
        # Whatever the result is, if we don't raise an exception, it's ok.
1985
 
        osutils.terminal_width()
1986
 
 
1987
 
class TestCreationOps(tests.TestCaseInTempDir):
1988
 
    _test_needs_features = [features.chown_feature]
1989
 
 
1990
 
    def setUp(self):
1991
 
        tests.TestCaseInTempDir.setUp(self)
1992
 
        self.overrideAttr(os, 'chown', self._dummy_chown)
1993
 
 
1994
 
        # params set by call to _dummy_chown
1995
 
        self.path = self.uid = self.gid = None
1996
 
 
1997
 
    def _dummy_chown(self, path, uid, gid):
1998
 
        self.path, self.uid, self.gid = path, uid, gid
1999
 
 
2000
 
    def test_copy_ownership_from_path(self):
2001
 
        """copy_ownership_from_path test with specified src."""
2002
 
        ownsrc = '/'
2003
 
        f = open('test_file', 'wt')
2004
 
        osutils.copy_ownership_from_path('test_file', ownsrc)
2005
 
 
2006
 
        s = os.stat(ownsrc)
2007
 
        self.assertEquals(self.path, 'test_file')
2008
 
        self.assertEquals(self.uid, s.st_uid)
2009
 
        self.assertEquals(self.gid, s.st_gid)
2010
 
 
2011
 
    def test_copy_ownership_nonesrc(self):
2012
 
        """copy_ownership_from_path test with src=None."""
2013
 
        f = open('test_file', 'wt')
2014
 
        # should use parent dir for permissions
2015
 
        osutils.copy_ownership_from_path('test_file')
2016
 
 
2017
 
        s = os.stat('..')
2018
 
        self.assertEquals(self.path, 'test_file')
2019
 
        self.assertEquals(self.uid, s.st_uid)
2020
 
        self.assertEquals(self.gid, s.st_gid)
 
1935
        self.assertEquals(None, osutils.terminal_width())