← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-08-24 21:59:21 UTC
  • mfrom: (5363.2.22 controldir-1)
  • Revision ID: pqm@pqm.ubuntu.com-20100824215921-p4nheij9k4x6i1jw
(jelmer) Split generic interface code out of bzrlib.bzrdir.BzrDir into
 bzrlib.controldir.ControlDir. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
27
27
 
28
28
from bzrlib import (
29
29
    errors,
 
30
    lazy_regex,
30
31
    osutils,
 
32
    symbol_versioning,
31
33
    tests,
 
34
    trace,
32
35
    win32utils,
33
36
    )
34
37
from bzrlib.tests import (
 
38
    features,
35
39
    file_utils,
36
40
    test__walkdirs_win32,
37
41
    )
52
56
 
53
57
UTF8DirReaderFeature = _UTF8DirReaderFeature()
54
58
 
 
59
term_ios_feature = tests.ModuleAvailableFeature('termios')
 
60
 
55
61
 
56
62
def _already_unicode(s):
57
63
    return s
58
64
 
59
65
 
60
 
def _fs_enc_to_unicode(s):
61
 
    return s.decode(osutils._fs_enc)
62
 
 
63
 
 
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.Win32ReadDirFeature.available():
 
88
    if test__walkdirs_win32.win32_readdir_feature.available():
87
89
        try:
88
90
            from bzrlib import _walkdirs_win32
89
 
            # TODO: check on windows, it may be that we need to use/add
90
 
            # safe_unicode instead of _fs_enc_to_unicode
91
91
            scenarios.append(
92
92
                ('win32',
93
93
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
94
 
                      _native_to_unicode=_fs_enc_to_unicode)))
 
94
                      _native_to_unicode=_already_unicode)))
95
95
        except ImportError:
96
96
            pass
97
97
    return scenarios
125
125
 
126
126
class TestRename(tests.TestCaseInTempDir):
127
127
 
 
128
    def create_file(self, filename, content):
 
129
        f = open(filename, 'wb')
 
130
        try:
 
131
            f.write(content)
 
132
        finally:
 
133
            f.close()
 
134
 
 
135
    def _fancy_rename(self, a, b):
 
136
        osutils.fancy_rename(a, b, rename_func=os.rename,
 
137
                             unlink_func=os.unlink)
 
138
 
128
139
    def test_fancy_rename(self):
129
140
        # This should work everywhere
130
 
        def rename(a, b):
131
 
            osutils.fancy_rename(a, b,
132
 
                    rename_func=os.rename,
133
 
                    unlink_func=os.unlink)
134
 
 
135
 
        open('a', 'wb').write('something in a\n')
136
 
        rename('a', 'b')
 
141
        self.create_file('a', 'something in a\n')
 
142
        self._fancy_rename('a', 'b')
137
143
        self.failIfExists('a')
138
144
        self.failUnlessExists('b')
139
145
        self.check_file_contents('b', 'something in a\n')
140
146
 
141
 
        open('a', 'wb').write('new something in a\n')
142
 
        rename('b', 'a')
 
147
        self.create_file('a', 'new something in a\n')
 
148
        self._fancy_rename('b', 'a')
143
149
 
144
150
        self.check_file_contents('a', 'something in a\n')
145
151
 
 
152
    def test_fancy_rename_fails_source_missing(self):
 
153
        # An exception should be raised, and the target should be left in place
 
154
        self.create_file('target', 'data in target\n')
 
155
        self.assertRaises((IOError, OSError), self._fancy_rename,
 
156
                          'missingsource', 'target')
 
157
        self.failUnlessExists('target')
 
158
        self.check_file_contents('target', 'data in target\n')
 
159
 
 
160
    def test_fancy_rename_fails_if_source_and_target_missing(self):
 
161
        self.assertRaises((IOError, OSError), self._fancy_rename,
 
162
                          'missingsource', 'missingtarget')
 
163
 
146
164
    def test_rename(self):
147
165
        # Rename should be semi-atomic on all platforms
148
 
        open('a', 'wb').write('something in a\n')
 
166
        self.create_file('a', 'something in a\n')
149
167
        osutils.rename('a', 'b')
150
168
        self.failIfExists('a')
151
169
        self.failUnlessExists('b')
152
170
        self.check_file_contents('b', 'something in a\n')
153
171
 
154
 
        open('a', 'wb').write('new something in a\n')
 
172
        self.create_file('a', 'new something in a\n')
155
173
        osutils.rename('b', 'a')
156
174
 
157
175
        self.check_file_contents('a', 'something in a\n')
294
312
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
295
313
        self.assertEqual("@", osutils.kind_marker("symlink"))
296
314
        self.assertEqual("+", osutils.kind_marker("tree-reference"))
297
 
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
 
315
        self.assertEqual("", osutils.kind_marker("fifo"))
 
316
        self.assertEqual("", osutils.kind_marker("socket"))
 
317
        self.assertEqual("", osutils.kind_marker("unknown"))
298
318
 
299
319
 
300
320
class TestUmask(tests.TestCaseInTempDir):
365
385
        # Instead blackbox.test_locale should check for localized
366
386
        # dates once they do occur in output strings.
367
387
 
 
388
    def test_format_date_with_offset_in_original_timezone(self):
 
389
        self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
 
390
            osutils.format_date_with_offset_in_original_timezone(0))
 
391
        self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
 
392
            osutils.format_date_with_offset_in_original_timezone(100000))
 
393
        self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
 
394
            osutils.format_date_with_offset_in_original_timezone(100000, 7200))
 
395
 
368
396
    def test_local_time_offset(self):
369
397
        """Test that local_time_offset() returns a sane value."""
370
398
        offset = osutils.local_time_offset()
446
474
    def test_canonical_relpath_simple(self):
447
475
        f = file('MixedCaseName', 'w')
448
476
        f.close()
449
 
        # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
450
 
        real_base_dir = osutils.realpath(self.test_base_dir)
451
 
        actual = osutils.canonical_relpath(real_base_dir, 'mixedcasename')
 
477
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
452
478
        self.failUnlessEqual('work/MixedCaseName', actual)
453
479
 
454
480
    def test_canonical_relpath_missing_tail(self):
455
481
        os.mkdir('MixedCaseParent')
456
 
        # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
457
 
        real_base_dir = osutils.realpath(self.test_base_dir)
458
 
        actual = osutils.canonical_relpath(real_base_dir,
 
482
        actual = osutils.canonical_relpath(self.test_base_dir,
459
483
                                           'mixedcaseparent/nochild')
460
484
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
461
485
 
462
486
 
 
487
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
 
488
 
 
489
    def assertRelpath(self, expected, base, path):
 
490
        actual = osutils._cicp_canonical_relpath(base, path)
 
491
        self.assertEqual(expected, actual)
 
492
 
 
493
    def test_simple(self):
 
494
        self.build_tree(['MixedCaseName'])
 
495
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
 
496
        self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
 
497
 
 
498
    def test_subdir_missing_tail(self):
 
499
        self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
 
500
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
 
501
        self.assertRelpath('MixedCaseParent/a_child', base,
 
502
                           'MixedCaseParent/a_child')
 
503
        self.assertRelpath('MixedCaseParent/a_child', base,
 
504
                           'MixedCaseParent/A_Child')
 
505
        self.assertRelpath('MixedCaseParent/not_child', base,
 
506
                           'MixedCaseParent/not_child')
 
507
 
 
508
    def test_at_root_slash(self):
 
509
        # We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
 
510
        # check...
 
511
        if osutils.MIN_ABS_PATHLENGTH > 1:
 
512
            raise tests.TestSkipped('relpath requires %d chars'
 
513
                                    % osutils.MIN_ABS_PATHLENGTH)
 
514
        self.assertRelpath('foo', '/', '/foo')
 
515
 
 
516
    def test_at_root_drive(self):
 
517
        if sys.platform != 'win32':
 
518
            raise tests.TestNotApplicable('we can only test drive-letter relative'
 
519
                                          ' paths on Windows where we have drive'
 
520
                                          ' letters.')
 
521
        # see bug #322807
 
522
        # The specific issue is that when at the root of a drive, 'abspath'
 
523
        # returns "C:/" or just "/". However, the code assumes that abspath
 
524
        # always returns something like "C:/foo" or "/foo" (no trailing slash).
 
525
        self.assertRelpath('foo', 'C:/', 'C:/foo')
 
526
        self.assertRelpath('foo', 'X:/', 'X:/foo')
 
527
        self.assertRelpath('foo', 'X:/', 'X://foo')
 
528
 
 
529
 
463
530
class TestPumpFile(tests.TestCase):
464
531
    """Test pumpfile method."""
465
532
 
796
863
        self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
797
864
        # relative path
798
865
        cwd = osutils.getcwd().rstrip('/')
799
 
        drive = osutils._nt_splitdrive(cwd)[0]
 
866
        drive = osutils.ntpath.splitdrive(cwd)[0]
800
867
        self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
801
868
        self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
802
869
        # unicode path
927
994
 
928
995
    def test_osutils_binding(self):
929
996
        from bzrlib.tests import test__chunks_to_lines
930
 
        if test__chunks_to_lines.CompiledChunksToLinesFeature.available():
 
997
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
931
998
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
932
999
        else:
933
1000
            from bzrlib._chunks_to_lines_py import chunks_to_lines
999
1066
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
1000
1067
 
1001
1068
    def test_walkdirs_os_error(self):
1002
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/338653>
 
1069
        # <https://bugs.launchpad.net/bzr/+bug/338653>
1003
1070
        # Pyrex readdir didn't raise useful messages if it had an error
1004
1071
        # reading the directory
1005
1072
        if sys.platform == 'win32':
1018
1085
        # Ensure the message contains the file name
1019
1086
        self.assertContainsRe(str(e), "\./test-unreadable")
1020
1087
 
 
1088
 
 
1089
    def test_walkdirs_encoding_error(self):
 
1090
        # <https://bugs.launchpad.net/bzr/+bug/488519>
 
1091
        # walkdirs didn't raise a useful message when the filenames
 
1092
        # are not using the filesystem's encoding
 
1093
 
 
1094
        # require a bytestring based filesystem
 
1095
        self.requireFeature(tests.ByteStringNamedFilesystem)
 
1096
 
 
1097
        tree = [
 
1098
            '.bzr',
 
1099
            '0file',
 
1100
            '1dir/',
 
1101
            '1dir/0file',
 
1102
            '1dir/1dir/',
 
1103
            '1file'
 
1104
            ]
 
1105
 
 
1106
        self.build_tree(tree)
 
1107
 
 
1108
        # rename the 1file to a latin-1 filename
 
1109
        os.rename("./1file", "\xe8file")
 
1110
 
 
1111
        self._save_platform_info()
 
1112
        win32utils.winver = None # Avoid the win32 detection code
 
1113
        osutils._fs_enc = 'UTF-8'
 
1114
 
 
1115
        # this should raise on error
 
1116
        def attempt():
 
1117
            for dirdetail, dirblock in osutils.walkdirs('.'):
 
1118
                pass
 
1119
 
 
1120
        self.assertRaises(errors.BadFilenameEncoding, attempt)
 
1121
 
1021
1122
    def test__walkdirs_utf8(self):
1022
1123
        tree = [
1023
1124
            '.bzr',
1073
1174
            dirblock[:] = new_dirblock
1074
1175
 
1075
1176
    def _save_platform_info(self):
1076
 
        cur_winver = win32utils.winver
1077
 
        cur_fs_enc = osutils._fs_enc
1078
 
        cur_dir_reader = osutils._selected_dir_reader
1079
 
        def restore():
1080
 
            win32utils.winver = cur_winver
1081
 
            osutils._fs_enc = cur_fs_enc
1082
 
            osutils._selected_dir_reader = cur_dir_reader
1083
 
        self.addCleanup(restore)
 
1177
        self.overrideAttr(win32utils, 'winver')
 
1178
        self.overrideAttr(osutils, '_fs_enc')
 
1179
        self.overrideAttr(osutils, '_selected_dir_reader')
1084
1180
 
1085
1181
    def assertDirReaderIs(self, expected):
1086
1182
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
1119
1215
 
1120
1216
    def test_force_walkdirs_utf8_nt(self):
1121
1217
        # Disabled because the thunk of the whole walkdirs api is disabled.
1122
 
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
 
1218
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1123
1219
        self._save_platform_info()
1124
1220
        win32utils.winver = 'Windows NT'
1125
1221
        from bzrlib._walkdirs_win32 import Win32ReadDir
1126
1222
        self.assertDirReaderIs(Win32ReadDir)
1127
1223
 
1128
1224
    def test_force_walkdirs_utf8_98(self):
1129
 
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
 
1225
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1130
1226
        self._save_platform_info()
1131
1227
        win32utils.winver = 'Windows 98'
1132
1228
        self.assertDirReaderIs(osutils.UnicodeDirReader)
1283
1379
        self.assertEqual(expected_dirblocks, result)
1284
1380
 
1285
1381
    def test__walkdirs_utf8_win32readdir(self):
1286
 
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
 
1382
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1287
1383
        self.requireFeature(tests.UnicodeFilenameFeature)
1288
1384
        from bzrlib._walkdirs_win32 import Win32ReadDir
1289
1385
        self._save_platform_info()
1340
1436
 
1341
1437
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1342
1438
        """make sure our Stat values are valid"""
1343
 
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
 
1439
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1344
1440
        self.requireFeature(tests.UnicodeFilenameFeature)
1345
1441
        from bzrlib._walkdirs_win32 import Win32ReadDir
1346
1442
        name0u = u'0file-\xb6'
1364
1460
 
1365
1461
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1366
1462
        """make sure our Stat values are valid"""
1367
 
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
 
1463
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1368
1464
        self.requireFeature(tests.UnicodeFilenameFeature)
1369
1465
        from bzrlib._walkdirs_win32 import Win32ReadDir
1370
1466
        name0u = u'0dir-\u062c\u0648'
1519
1615
        def cleanup():
1520
1616
            if 'BZR_TEST_ENV_VAR' in os.environ:
1521
1617
                del os.environ['BZR_TEST_ENV_VAR']
1522
 
 
1523
1618
        self.addCleanup(cleanup)
1524
1619
 
1525
1620
    def test_set(self):
1573
1668
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
1574
1669
        self.build_tree_contents([('foo', text)])
1575
1670
        expected_sha = osutils.sha_string(text)
1576
 
        f = open('foo')
 
1671
        f = open('foo', 'rb')
1577
1672
        self.addCleanup(f.close)
1578
1673
        size, sha = osutils.size_sha_file(f)
1579
1674
        self.assertEqual(38, size)
1612
1707
 
1613
1708
class TestReCompile(tests.TestCase):
1614
1709
 
 
1710
    def _deprecated_re_compile_checked(self, *args, **kwargs):
 
1711
        return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
 
1712
            osutils.re_compile_checked, *args, **kwargs)
 
1713
 
1615
1714
    def test_re_compile_checked(self):
1616
 
        r = osutils.re_compile_checked(r'A*', re.IGNORECASE)
 
1715
        r = self._deprecated_re_compile_checked(r'A*', re.IGNORECASE)
1617
1716
        self.assertTrue(r.match('aaaa'))
1618
1717
        self.assertTrue(r.match('aAaA'))
1619
1718
 
1620
1719
    def test_re_compile_checked_error(self):
1621
1720
        # like https://bugs.launchpad.net/bzr/+bug/251352
 
1721
 
 
1722
        # Due to possible test isolation error, re.compile is not lazy at
 
1723
        # this point. We re-install lazy compile.
 
1724
        lazy_regex.install_lazy_compile()
1622
1725
        err = self.assertRaises(
1623
1726
            errors.BzrCommandError,
1624
 
            osutils.re_compile_checked, '*', re.IGNORECASE, 'test case')
 
1727
            self._deprecated_re_compile_checked, '*', re.IGNORECASE, 'test case')
1625
1728
        self.assertEqual(
1626
 
            "Invalid regular expression in test case: '*': "
1627
 
            "nothing to repeat",
 
1729
            'Invalid regular expression in test case: '
 
1730
            '"*" nothing to repeat',
1628
1731
            str(err))
1629
1732
 
1630
1733
 
1636
1739
 
1637
1740
    def setUp(self):
1638
1741
        tests.TestCaseInTempDir.setUp(self)
1639
 
 
1640
 
        # Save platform specific info and reset it
1641
 
        cur_dir_reader = osutils._selected_dir_reader
1642
 
 
1643
 
        def restore():
1644
 
            osutils._selected_dir_reader = cur_dir_reader
1645
 
        self.addCleanup(restore)
1646
 
 
1647
 
        osutils._selected_dir_reader = self._dir_reader_class()
 
1742
        self.overrideAttr(osutils,
 
1743
                          '_selected_dir_reader', self._dir_reader_class())
1648
1744
 
1649
1745
    def _get_ascii_tree(self):
1650
1746
        tree = [
1795
1891
 
1796
1892
class TestConcurrency(tests.TestCase):
1797
1893
 
 
1894
    def setUp(self):
 
1895
        super(TestConcurrency, self).setUp()
 
1896
        self.overrideAttr(osutils, '_cached_local_concurrency')
 
1897
 
1798
1898
    def test_local_concurrency(self):
1799
1899
        concurrency = osutils.local_concurrency()
1800
1900
        self.assertIsInstance(concurrency, int)
 
1901
 
 
1902
    def test_local_concurrency_environment_variable(self):
 
1903
        os.environ['BZR_CONCURRENCY'] = '2'
 
1904
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
 
1905
        os.environ['BZR_CONCURRENCY'] = '3'
 
1906
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
 
1907
        os.environ['BZR_CONCURRENCY'] = 'foo'
 
1908
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
 
1909
 
 
1910
    def test_option_concurrency(self):
 
1911
        os.environ['BZR_CONCURRENCY'] = '1'
 
1912
        self.run_bzr('rocks --concurrency 42')
 
1913
        # Command line overrides envrionment variable
 
1914
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
 
1915
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
 
1916
 
 
1917
 
 
1918
class TestFailedToLoadExtension(tests.TestCase):
 
1919
 
 
1920
    def _try_loading(self):
 
1921
        try:
 
1922
            import bzrlib._fictional_extension_py
 
1923
        except ImportError, e:
 
1924
            osutils.failed_to_load_extension(e)
 
1925
            return True
 
1926
 
 
1927
    def setUp(self):
 
1928
        super(TestFailedToLoadExtension, self).setUp()
 
1929
        self.overrideAttr(osutils, '_extension_load_failures', [])
 
1930
 
 
1931
    def test_failure_to_load(self):
 
1932
        self._try_loading()
 
1933
        self.assertLength(1, osutils._extension_load_failures)
 
1934
        self.assertEquals(osutils._extension_load_failures[0],
 
1935
            "No module named _fictional_extension_py")
 
1936
 
 
1937
    def test_report_extension_load_failures_no_warning(self):
 
1938
        self.assertTrue(self._try_loading())
 
1939
        warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
 
1940
        # it used to give a Python warning; it no longer does
 
1941
        self.assertLength(0, warnings)
 
1942
 
 
1943
    def test_report_extension_load_failures_message(self):
 
1944
        log = StringIO()
 
1945
        trace.push_log_file(log)
 
1946
        self.assertTrue(self._try_loading())
 
1947
        osutils.report_extension_load_failures()
 
1948
        self.assertContainsRe(
 
1949
            log.getvalue(),
 
1950
            r"bzr: warning: some compiled extensions could not be loaded; "
 
1951
            "see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
 
1952
            )
 
1953
 
 
1954
 
 
1955
class TestTerminalWidth(tests.TestCase):
 
1956
 
 
1957
    def setUp(self):
 
1958
        tests.TestCase.setUp(self)
 
1959
        self._orig_terminal_size_state = osutils._terminal_size_state
 
1960
        self._orig_first_terminal_size = osutils._first_terminal_size
 
1961
        self.addCleanup(self.restore_osutils_globals)
 
1962
        osutils._terminal_size_state = 'no_data'
 
1963
        osutils._first_terminal_size = None
 
1964
 
 
1965
    def restore_osutils_globals(self):
 
1966
        osutils._terminal_size_state = self._orig_terminal_size_state
 
1967
        osutils._first_terminal_size = self._orig_first_terminal_size
 
1968
 
 
1969
    def replace_stdout(self, new):
 
1970
        self.overrideAttr(sys, 'stdout', new)
 
1971
 
 
1972
    def replace__terminal_size(self, new):
 
1973
        self.overrideAttr(osutils, '_terminal_size', new)
 
1974
 
 
1975
    def set_fake_tty(self):
 
1976
 
 
1977
        class I_am_a_tty(object):
 
1978
            def isatty(self):
 
1979
                return True
 
1980
 
 
1981
        self.replace_stdout(I_am_a_tty())
 
1982
 
 
1983
    def test_default_values(self):
 
1984
        self.assertEqual(80, osutils.default_terminal_width)
 
1985
 
 
1986
    def test_defaults_to_BZR_COLUMNS(self):
 
1987
        # BZR_COLUMNS is set by the test framework
 
1988
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
 
1989
        os.environ['BZR_COLUMNS'] = '12'
 
1990
        self.assertEqual(12, osutils.terminal_width())
 
1991
 
 
1992
    def test_falls_back_to_COLUMNS(self):
 
1993
        del os.environ['BZR_COLUMNS']
 
1994
        self.assertNotEqual('42', os.environ['COLUMNS'])
 
1995
        self.set_fake_tty()
 
1996
        os.environ['COLUMNS'] = '42'
 
1997
        self.assertEqual(42, osutils.terminal_width())
 
1998
 
 
1999
    def test_tty_default_without_columns(self):
 
2000
        del os.environ['BZR_COLUMNS']
 
2001
        del os.environ['COLUMNS']
 
2002
 
 
2003
        def terminal_size(w, h):
 
2004
            return 42, 42
 
2005
 
 
2006
        self.set_fake_tty()
 
2007
        # We need to override the osutils definition as it depends on the
 
2008
        # running environment that we can't control (PQM running without a
 
2009
        # controlling terminal is one example).
 
2010
        self.replace__terminal_size(terminal_size)
 
2011
        self.assertEqual(42, osutils.terminal_width())
 
2012
 
 
2013
    def test_non_tty_default_without_columns(self):
 
2014
        del os.environ['BZR_COLUMNS']
 
2015
        del os.environ['COLUMNS']
 
2016
        self.replace_stdout(None)
 
2017
        self.assertEqual(None, osutils.terminal_width())
 
2018
 
 
2019
    def test_no_TIOCGWINSZ(self):
 
2020
        self.requireFeature(term_ios_feature)
 
2021
        termios = term_ios_feature.module
 
2022
        # bug 63539 is about a termios without TIOCGWINSZ attribute
 
2023
        try:
 
2024
            orig = termios.TIOCGWINSZ
 
2025
        except AttributeError:
 
2026
            # We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
 
2027
            pass
 
2028
        else:
 
2029
            self.overrideAttr(termios, 'TIOCGWINSZ')
 
2030
            del termios.TIOCGWINSZ
 
2031
        del os.environ['BZR_COLUMNS']
 
2032
        del os.environ['COLUMNS']
 
2033
        # Whatever the result is, if we don't raise an exception, it's ok.
 
2034
        osutils.terminal_width()
 
2035
 
 
2036
class TestCreationOps(tests.TestCaseInTempDir):
 
2037
    _test_needs_features = [features.chown_feature]
 
2038
 
 
2039
    def setUp(self):
 
2040
        tests.TestCaseInTempDir.setUp(self)
 
2041
        self.overrideAttr(os, 'chown', self._dummy_chown)
 
2042
 
 
2043
        # params set by call to _dummy_chown
 
2044
        self.path = self.uid = self.gid = None
 
2045
 
 
2046
    def _dummy_chown(self, path, uid, gid):
 
2047
        self.path, self.uid, self.gid = path, uid, gid
 
2048
 
 
2049
    def test_copy_ownership_from_path(self):
 
2050
        """copy_ownership_from_path test with specified src."""
 
2051
        ownsrc = '/'
 
2052
        f = open('test_file', 'wt')
 
2053
        osutils.copy_ownership_from_path('test_file', ownsrc)
 
2054
 
 
2055
        s = os.stat(ownsrc)
 
2056
        self.assertEquals(self.path, 'test_file')
 
2057
        self.assertEquals(self.uid, s.st_uid)
 
2058
        self.assertEquals(self.gid, s.st_gid)
 
2059
 
 
2060
    def test_copy_ownership_nonesrc(self):
 
2061
        """copy_ownership_from_path test with src=None."""
 
2062
        f = open('test_file', 'wt')
 
2063
        # should use parent dir for permissions
 
2064
        osutils.copy_ownership_from_path('test_file')
 
2065
 
 
2066
        s = os.stat('..')
 
2067
        self.assertEquals(self.path, 'test_file')
 
2068
        self.assertEquals(self.uid, s.st_uid)
 
2069
        self.assertEquals(self.gid, s.st_gid)
 
2070
 
 
2071
class TestGetuserUnicode(tests.TestCase):
 
2072
 
 
2073
    def test_ascii_user(self):
 
2074
        osutils.set_or_unset_env('LOGNAME', 'jrandom')
 
2075
        self.assertEqual(u'jrandom', osutils.getuser_unicode())
 
2076
 
 
2077
    def test_unicode_user(self):
 
2078
        ue = osutils.get_user_encoding()
 
2079
        osutils.set_or_unset_env('LOGNAME', u'jrandom\xb6'.encode(ue))
 
2080
        self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())