98
def load_tests(basic_tests, module, loader):
99
suite = loader.suiteClass()
100
dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
101
basic_tests, tests.condition_isinstance(TestDirReader))
102
tests.multiply_tests(dir_reader_tests, dir_reader_scenarios(), suite)
103
suite.addTest(remaining_tests)
105
load_tests = load_tests_apply_scenarios
107
108
class TestContainsWhitespace(tests.TestCase):
109
110
def test_contains_whitespace(self):
110
self.failUnless(osutils.contains_whitespace(u' '))
111
self.failUnless(osutils.contains_whitespace(u'hello there'))
112
self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
113
self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
114
self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
115
self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
111
self.assertTrue(osutils.contains_whitespace(u' '))
112
self.assertTrue(osutils.contains_whitespace(u'hello there'))
113
self.assertTrue(osutils.contains_whitespace(u'hellothere\n'))
114
self.assertTrue(osutils.contains_whitespace(u'hello\nthere'))
115
self.assertTrue(osutils.contains_whitespace(u'hello\rthere'))
116
self.assertTrue(osutils.contains_whitespace(u'hello\tthere'))
117
118
# \xa0 is "Non-breaking-space" which on some python locales thinks it
118
119
# is whitespace, but we do not.
119
self.failIf(osutils.contains_whitespace(u''))
120
self.failIf(osutils.contains_whitespace(u'hellothere'))
121
self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
120
self.assertFalse(osutils.contains_whitespace(u''))
121
self.assertFalse(osutils.contains_whitespace(u'hellothere'))
122
self.assertFalse(osutils.contains_whitespace(u'hello\xa0there'))
124
125
class TestRename(tests.TestCaseInTempDir):
137
138
def test_fancy_rename(self):
138
139
# This should work everywhere
139
self.create_file('a', 'something in a\n')
140
self.create_file('a', b'something in a\n')
140
141
self._fancy_rename('a', 'b')
141
self.failIfExists('a')
142
self.failUnlessExists('b')
143
self.check_file_contents('b', 'something in a\n')
142
self.assertPathDoesNotExist('a')
143
self.assertPathExists('b')
144
self.check_file_contents('b', b'something in a\n')
145
self.create_file('a', 'new something in a\n')
146
self.create_file('a', b'new something in a\n')
146
147
self._fancy_rename('b', 'a')
148
self.check_file_contents('a', 'something in a\n')
149
self.check_file_contents('a', b'something in a\n')
150
151
def test_fancy_rename_fails_source_missing(self):
151
152
# An exception should be raised, and the target should be left in place
152
self.create_file('target', 'data in target\n')
153
self.create_file('target', b'data in target\n')
153
154
self.assertRaises((IOError, OSError), self._fancy_rename,
154
155
'missingsource', 'target')
155
self.failUnlessExists('target')
156
self.check_file_contents('target', 'data in target\n')
156
self.assertPathExists('target')
157
self.check_file_contents('target', b'data in target\n')
158
159
def test_fancy_rename_fails_if_source_and_target_missing(self):
159
160
self.assertRaises((IOError, OSError), self._fancy_rename,
418
438
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
441
class TestFdatasync(tests.TestCaseInTempDir):
443
def do_fdatasync(self):
444
f = tempfile.NamedTemporaryFile()
445
osutils.fdatasync(f.fileno())
449
def raise_eopnotsupp(*args, **kwargs):
450
raise IOError(errno.EOPNOTSUPP, os.strerror(errno.EOPNOTSUPP))
453
def raise_enotsup(*args, **kwargs):
454
raise IOError(errno.ENOTSUP, os.strerror(errno.ENOTSUP))
456
def test_fdatasync_handles_system_function(self):
457
self.overrideAttr(os, "fdatasync")
460
def test_fdatasync_handles_no_fdatasync_no_fsync(self):
461
self.overrideAttr(os, "fdatasync")
462
self.overrideAttr(os, "fsync")
465
def test_fdatasync_handles_no_EOPNOTSUPP(self):
466
self.overrideAttr(errno, "EOPNOTSUPP")
469
def test_fdatasync_catches_ENOTSUP(self):
470
enotsup = getattr(errno, "ENOTSUP", None)
472
raise tests.TestNotApplicable("No ENOTSUP on this platform")
473
self.overrideAttr(os, "fdatasync", self.raise_enotsup)
476
def test_fdatasync_catches_EOPNOTSUPP(self):
477
enotsup = getattr(errno, "EOPNOTSUPP", None)
479
raise tests.TestNotApplicable("No EOPNOTSUPP on this platform")
480
self.overrideAttr(os, "fdatasync", self.raise_eopnotsupp)
421
484
class TestLinks(tests.TestCaseInTempDir):
423
486
def test_dereference_path(self):
424
self.requireFeature(tests.SymlinkFeature)
487
self.requireFeature(features.SymlinkFeature)
425
488
cwd = osutils.realpath('.')
427
490
bar_path = osutils.pathjoin(cwd, 'bar')
677
739
class TestPumpStringFile(tests.TestCase):
679
741
def test_empty(self):
681
osutils.pump_string_file("", output)
682
self.assertEqual("", output.getvalue())
743
osutils.pump_string_file(b"", output)
744
self.assertEqual(b"", output.getvalue())
684
746
def test_more_than_segment_size(self):
686
osutils.pump_string_file("123456789", output, 2)
687
self.assertEqual("123456789", output.getvalue())
748
osutils.pump_string_file(b"123456789", output, 2)
749
self.assertEqual(b"123456789", output.getvalue())
689
751
def test_segment_size(self):
691
osutils.pump_string_file("12", output, 2)
692
self.assertEqual("12", output.getvalue())
753
osutils.pump_string_file(b"12", output, 2)
754
self.assertEqual(b"12", output.getvalue())
694
756
def test_segment_size_multiple(self):
696
osutils.pump_string_file("1234", output, 2)
697
self.assertEqual("1234", output.getvalue())
758
osutils.pump_string_file(b"1234", output, 2)
759
self.assertEqual(b"1234", output.getvalue())
700
762
class TestRelpath(tests.TestCase):
810
862
self.assertEqual(None, osutils.safe_file_id(None))
865
class TestSendAll(tests.TestCase):
867
def test_send_with_disconnected_socket(self):
868
class DisconnectedSocket(object):
869
def __init__(self, err):
871
def send(self, content):
875
# All of these should be treated as ConnectionReset
877
for err_cls in (IOError, socket.error):
878
for errnum in osutils._end_of_stream_errors:
879
errs.append(err_cls(errnum))
881
sock = DisconnectedSocket(err)
882
self.assertRaises(errors.ConnectionReset,
883
osutils.send_all, sock, b'some more content')
885
def test_send_with_no_progress(self):
886
# See https://bugs.launchpad.net/bzr/+bug/1047309
887
# It seems that paramiko can get into a state where it doesn't error,
888
# but it returns 0 bytes sent for requests over and over again.
889
class NoSendingSocket(object):
892
def send(self, bytes):
894
if self.call_count > 100:
895
# Prevent the test suite from hanging
896
raise RuntimeError('too many calls')
898
sock = NoSendingSocket()
899
self.assertRaises(errors.ConnectionReset,
900
osutils.send_all, sock, b'content')
901
self.assertEqual(1, sock.call_count)
904
class TestPosixFuncs(tests.TestCase):
905
"""Test that the posix version of normpath returns an appropriate path
906
when used with 2 leading slashes."""
908
def test_normpath(self):
909
self.assertEqual('/etc/shadow', osutils._posix_normpath('/etc/shadow'))
910
self.assertEqual('/etc/shadow', osutils._posix_normpath('//etc/shadow'))
911
self.assertEqual('/etc/shadow', osutils._posix_normpath('///etc/shadow'))
813
914
class TestWin32Funcs(tests.TestCase):
814
915
"""Test that _win32 versions of os utilities return appropriate paths."""
816
917
def test_abspath(self):
918
self.requireFeature(features.win32_feature)
817
919
self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
818
920
self.assertEqual('C:/foo', osutils._win32_abspath('C:/foo'))
819
921
self.assertEqual('//HOST/path', osutils._win32_abspath(r'\\HOST\path'))
908
1000
self.assertFalse('\\' in tmpdir)
910
1002
def test_rename(self):
1003
with open('a', 'wb') as a:
1005
with open('b', 'wb') as b:
918
1008
osutils._win32_rename('b', 'a')
919
self.failUnlessExists('a')
920
self.failIfExists('b')
921
self.assertFileEqual('baz\n', 'a')
1009
self.assertPathExists('a')
1010
self.assertPathDoesNotExist('b')
1011
self.assertFileEqual(b'baz\n', 'a')
923
1013
def test_rename_missing_file(self):
1014
with open('a', 'wb') as a:
929
1018
osutils._win32_rename('b', 'a')
930
except (IOError, OSError), e:
1019
except (IOError, OSError) as e:
931
1020
self.assertEqual(errno.ENOENT, e.errno)
932
self.assertFileEqual('foo\n', 'a')
1021
self.assertFileEqual(b'foo\n', 'a')
934
1023
def test_rename_missing_dir(self):
937
1026
osutils._win32_rename('b', 'a')
938
except (IOError, OSError), e:
1027
except (IOError, OSError) as e:
939
1028
self.assertEqual(errno.ENOENT, e.errno)
941
1030
def test_rename_current_dir(self):
1071
1160
self.assertExpectedBlocks(expected_dirblocks[1:], result)
1073
1162
def test_walkdirs_os_error(self):
1074
# <https://bugs.edge.launchpad.net/bzr/+bug/338653>
1163
# <https://bugs.launchpad.net/bzr/+bug/338653>
1075
1164
# Pyrex readdir didn't raise useful messages if it had an error
1076
1165
# reading the directory
1077
1166
if sys.platform == 'win32':
1078
1167
raise tests.TestNotApplicable(
1079
1168
"readdir IOError not tested on win32")
1169
self.requireFeature(features.not_running_as_root)
1080
1170
os.mkdir("test-unreadable")
1081
1171
os.chmod("test-unreadable", 0000)
1082
1172
# must chmod it back so that it can be removed
1083
self.addCleanup(os.chmod, "test-unreadable", 0700)
1173
self.addCleanup(os.chmod, "test-unreadable", 0o700)
1084
1174
# The error is not raised until the generator is actually evaluated.
1085
1175
# (It would be ok if it happened earlier but at the moment it
1087
1177
e = self.assertRaises(OSError, list, osutils._walkdirs_utf8("."))
1088
self.assertEquals('./test-unreadable', e.filename)
1089
self.assertEquals(errno.EACCES, e.errno)
1178
self.assertEqual('./test-unreadable', e.filename)
1179
self.assertEqual(errno.EACCES, e.errno)
1090
1180
# Ensure the message contains the file name
1091
self.assertContainsRe(str(e), "\./test-unreadable")
1181
self.assertContainsRe(str(e), "\\./test-unreadable")
1184
def test_walkdirs_encoding_error(self):
1185
# <https://bugs.launchpad.net/bzr/+bug/488519>
1186
# walkdirs didn't raise a useful message when the filenames
1187
# are not using the filesystem's encoding
1189
# require a bytestring based filesystem
1190
self.requireFeature(features.ByteStringNamedFilesystem)
1201
self.build_tree(tree)
1203
# rename the 1file to a latin-1 filename
1204
os.rename("./1file", "\xe8file")
1205
if "\xe8file" not in os.listdir("."):
1206
self.skipTest("Lack filesystem that preserves arbitrary bytes")
1208
self._save_platform_info()
1209
osutils._fs_enc = 'UTF-8'
1211
# this should raise on error
1213
for dirdetail, dirblock in osutils.walkdirs('.'):
1216
self.assertRaises(errors.BadFilenameEncoding, attempt)
1093
1218
def test__walkdirs_utf8(self):
1160
1284
def test_force_walkdirs_utf8_fs_utf8(self):
1161
1285
self.requireFeature(UTF8DirReaderFeature)
1162
1286
self._save_platform_info()
1163
win32utils.winver = None # Avoid the win32 detection code
1164
osutils._fs_enc = 'UTF-8'
1165
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1287
osutils._fs_enc = 'utf-8'
1288
self.assertDirReaderIs(
1289
UTF8DirReaderFeature.module.UTF8DirReader)
1167
1291
def test_force_walkdirs_utf8_fs_ascii(self):
1168
1292
self.requireFeature(UTF8DirReaderFeature)
1169
1293
self._save_platform_info()
1170
win32utils.winver = None # Avoid the win32 detection code
1171
osutils._fs_enc = 'US-ASCII'
1172
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1174
def test_force_walkdirs_utf8_fs_ANSI(self):
1175
self.requireFeature(UTF8DirReaderFeature)
1176
self._save_platform_info()
1177
win32utils.winver = None # Avoid the win32 detection code
1178
osutils._fs_enc = 'ANSI_X3.4-1968'
1179
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1294
osutils._fs_enc = 'ascii'
1295
self.assertDirReaderIs(
1296
UTF8DirReaderFeature.module.UTF8DirReader)
1181
1298
def test_force_walkdirs_utf8_fs_latin1(self):
1182
1299
self._save_platform_info()
1183
win32utils.winver = None # Avoid the win32 detection code
1184
osutils._fs_enc = 'latin1'
1300
osutils._fs_enc = 'iso-8859-1'
1185
1301
self.assertDirReaderIs(osutils.UnicodeDirReader)
1187
1303
def test_force_walkdirs_utf8_nt(self):
1188
1304
# Disabled because the thunk of the whole walkdirs api is disabled.
1189
1305
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1190
1306
self._save_platform_info()
1191
win32utils.winver = 'Windows NT'
1192
from bzrlib._walkdirs_win32 import Win32ReadDir
1307
from .._walkdirs_win32 import Win32ReadDir
1193
1308
self.assertDirReaderIs(Win32ReadDir)
1195
def test_force_walkdirs_utf8_98(self):
1196
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1197
self._save_platform_info()
1198
win32utils.winver = 'Windows 98'
1199
self.assertDirReaderIs(osutils.UnicodeDirReader)
1201
1310
def test_unicode_walkdirs(self):
1202
1311
"""Walkdirs should always return unicode paths."""
1203
self.requireFeature(tests.UnicodeFilenameFeature)
1312
self.requireFeature(features.UnicodeFilenameFeature)
1204
1313
name0 = u'0file-\xb6'
1205
1314
name1 = u'1dir-\u062c\u0648'
1206
1315
name2 = u'2file-\u0633'
1580
1686
def setUp(self):
1581
1687
super(TestSetUnsetEnv, self).setUp()
1583
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
1689
self.assertEqual(None, os.environ.get('BRZ_TEST_ENV_VAR'),
1584
1690
'Environment was not cleaned up properly.'
1585
' Variable BZR_TEST_ENV_VAR should not exist.')
1691
' Variable BRZ_TEST_ENV_VAR should not exist.')
1587
if 'BZR_TEST_ENV_VAR' in os.environ:
1588
del os.environ['BZR_TEST_ENV_VAR']
1693
if 'BRZ_TEST_ENV_VAR' in os.environ:
1694
del os.environ['BRZ_TEST_ENV_VAR']
1589
1695
self.addCleanup(cleanup)
1591
1697
def test_set(self):
1592
1698
"""Test that we can set an env variable"""
1593
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1699
old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'foo')
1594
1700
self.assertEqual(None, old)
1595
self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
1701
self.assertEqual('foo', os.environ.get('BRZ_TEST_ENV_VAR'))
1597
1703
def test_double_set(self):
1598
1704
"""Test that we get the old value out"""
1599
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1600
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
1705
osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'foo')
1706
old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'bar')
1601
1707
self.assertEqual('foo', old)
1602
self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
1708
self.assertEqual('bar', os.environ.get('BRZ_TEST_ENV_VAR'))
1604
1710
def test_unicode(self):
1605
1711
"""Environment can only contain plain strings
1612
1718
'Cannot find a unicode character that works in encoding %s'
1613
1719
% (osutils.get_user_encoding(),))
1615
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1616
self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
1721
old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', uni_val)
1722
self.assertEqual(env_val, os.environ.get('BRZ_TEST_ENV_VAR'))
1618
1724
def test_unset(self):
1619
1725
"""Test that passing None will remove the env var"""
1620
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1621
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1726
osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'foo')
1727
old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', None)
1622
1728
self.assertEqual('foo', old)
1623
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1624
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1729
self.assertEqual(None, os.environ.get('BRZ_TEST_ENV_VAR'))
1730
self.assertFalse('BRZ_TEST_ENV_VAR' in os.environ)
1627
1733
class TestSizeShaFile(tests.TestCaseInTempDir):
1629
1735
def test_sha_empty(self):
1630
self.build_tree_contents([('foo', '')])
1736
self.build_tree_contents([('foo', b'')])
1631
1737
expected_sha = osutils.sha_string('')
1632
1738
f = open('foo')
1633
1739
self.addCleanup(f.close)
1663
1769
class TestResourceLoading(tests.TestCaseInTempDir):
1665
1771
def test_resource_string(self):
1666
# test resource in bzrlib
1667
text = osutils.resource_string('bzrlib', 'debug.py')
1772
# test resource in breezy
1773
text = osutils.resource_string('breezy', 'debug.py')
1668
1774
self.assertContainsRe(text, "debug_flags = set()")
1669
# test resource under bzrlib
1670
text = osutils.resource_string('bzrlib.ui', 'text.py')
1775
# test resource under breezy
1776
text = osutils.resource_string('breezy.ui', 'text.py')
1671
1777
self.assertContainsRe(text, "class TextUIFactory")
1672
1778
# test unsupported package
1673
1779
self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1675
1781
# test unknown resource
1676
self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1679
class TestReCompile(tests.TestCase):
1681
def test_re_compile_checked(self):
1682
r = osutils.re_compile_checked(r'A*', re.IGNORECASE)
1683
self.assertTrue(r.match('aaaa'))
1684
self.assertTrue(r.match('aAaA'))
1686
def test_re_compile_checked_error(self):
1687
# like https://bugs.launchpad.net/bzr/+bug/251352
1688
err = self.assertRaises(
1689
errors.BzrCommandError,
1690
osutils.re_compile_checked, '*', re.IGNORECASE, 'test case')
1692
"Invalid regular expression in test case: '*': "
1693
"nothing to repeat",
1782
self.assertRaises(IOError, osutils.resource_string, 'breezy', 'yyy.xx')
1697
1785
class TestDirReader(tests.TestCaseInTempDir):
1787
scenarios = dir_reader_scenarios()
1699
1789
# Set by load_tests
1700
1790
_dir_reader_class = None
1701
1791
_native_to_unicode = None
1703
1793
def setUp(self):
1704
tests.TestCaseInTempDir.setUp(self)
1794
super(TestDirReader, self).setUp()
1705
1795
self.overrideAttr(osutils,
1706
1796
'_selected_dir_reader', self._dir_reader_class())
1863
1950
self.assertIsInstance(concurrency, int)
1865
1952
def test_local_concurrency_environment_variable(self):
1866
os.environ['BZR_CONCURRENCY'] = '2'
1953
self.overrideEnv('BRZ_CONCURRENCY', '2')
1867
1954
self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1868
os.environ['BZR_CONCURRENCY'] = '3'
1955
self.overrideEnv('BRZ_CONCURRENCY', '3')
1869
1956
self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1870
os.environ['BZR_CONCURRENCY'] = 'foo'
1957
self.overrideEnv('BRZ_CONCURRENCY', 'foo')
1871
1958
self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1873
1960
def test_option_concurrency(self):
1874
os.environ['BZR_CONCURRENCY'] = '1'
1961
self.overrideEnv('BRZ_CONCURRENCY', '1')
1875
1962
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))
1963
# Command line overrides environment variable
1964
self.assertEqual('42', os.environ['BRZ_CONCURRENCY'])
1965
self.assertEqual(42, osutils.local_concurrency(use_cache=False))
1881
1968
class TestFailedToLoadExtension(tests.TestCase):
1883
1970
def _try_loading(self):
1885
import bzrlib._fictional_extension_py
1886
except ImportError, e:
1972
import breezy._fictional_extension_py
1973
except ImportError as e:
1887
1974
osutils.failed_to_load_extension(e)
1934
2033
def test_default_values(self):
1935
2034
self.assertEqual(80, osutils.default_terminal_width)
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'
2036
def test_defaults_to_BRZ_COLUMNS(self):
2037
# BRZ_COLUMNS is set by the test framework
2038
self.assertNotEqual('12', os.environ['BRZ_COLUMNS'])
2039
self.overrideEnv('BRZ_COLUMNS', '12')
1941
2040
self.assertEqual(12, osutils.terminal_width())
2042
def test_BRZ_COLUMNS_0_no_limit(self):
2043
self.overrideEnv('BRZ_COLUMNS', '0')
2044
self.assertEqual(None, osutils.terminal_width())
1943
2046
def test_falls_back_to_COLUMNS(self):
1944
del os.environ['BZR_COLUMNS']
2047
self.overrideEnv('BRZ_COLUMNS', None)
1945
2048
self.assertNotEqual('42', os.environ['COLUMNS'])
1946
2049
self.set_fake_tty()
1947
os.environ['COLUMNS'] = '42'
2050
self.overrideEnv('COLUMNS', '42')
1948
2051
self.assertEqual(42, osutils.terminal_width())
1950
2053
def test_tty_default_without_columns(self):
1951
del os.environ['BZR_COLUMNS']
1952
del os.environ['COLUMNS']
2054
self.overrideEnv('BRZ_COLUMNS', None)
2055
self.overrideEnv('COLUMNS', None)
1954
2057
def terminal_size(w, h):
2015
2119
osutils.copy_ownership_from_path('test_file')
2017
2121
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)
2122
self.assertEqual(self.path, 'test_file')
2123
self.assertEqual(self.uid, s.st_uid)
2124
self.assertEqual(self.gid, s.st_gid)
2127
class TestPathFromEnviron(tests.TestCase):
2129
def test_is_unicode(self):
2130
self.overrideEnv('BRZ_TEST_PATH', './anywhere at all/')
2131
path = osutils.path_from_environ('BRZ_TEST_PATH')
2132
self.assertIsInstance(path, text_type)
2133
self.assertEqual(u'./anywhere at all/', path)
2135
def test_posix_path_env_ascii(self):
2136
self.overrideEnv('BRZ_TEST_PATH', '/tmp')
2137
home = osutils._posix_path_from_environ('BRZ_TEST_PATH')
2138
self.assertIsInstance(home, text_type)
2139
self.assertEqual(u'/tmp', home)
2141
def test_posix_path_env_unicode(self):
2142
self.requireFeature(features.ByteStringNamedFilesystem)
2143
self.overrideEnv('BRZ_TEST_PATH', '/home/\xa7test')
2144
self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
2145
self.assertEqual(u'/home/\xa7test',
2146
osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2147
osutils._fs_enc = "iso8859-5"
2148
self.assertEqual(u'/home/\u0407test',
2149
osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2150
osutils._fs_enc = "utf-8"
2151
self.assertRaises(errors.BadFilenameEncoding,
2152
osutils._posix_path_from_environ, 'BRZ_TEST_PATH')
2155
class TestGetHomeDir(tests.TestCase):
2157
def test_is_unicode(self):
2158
home = osutils._get_home_dir()
2159
self.assertIsInstance(home, text_type)
2161
def test_posix_homeless(self):
2162
self.overrideEnv('HOME', None)
2163
home = osutils._get_home_dir()
2164
self.assertIsInstance(home, text_type)
2166
def test_posix_home_ascii(self):
2167
self.overrideEnv('HOME', '/home/test')
2168
home = osutils._posix_get_home_dir()
2169
self.assertIsInstance(home, text_type)
2170
self.assertEqual(u'/home/test', home)
2172
def test_posix_home_unicode(self):
2173
self.requireFeature(features.ByteStringNamedFilesystem)
2174
self.overrideEnv('HOME', '/home/\xa7test')
2175
self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
2176
self.assertEqual(u'/home/\xa7test', osutils._posix_get_home_dir())
2177
osutils._fs_enc = "iso8859-5"
2178
self.assertEqual(u'/home/\u0407test', osutils._posix_get_home_dir())
2179
osutils._fs_enc = "utf-8"
2180
self.assertRaises(errors.BadFilenameEncoding,
2181
osutils._posix_get_home_dir)
2184
class TestGetuserUnicode(tests.TestCase):
2186
def test_is_unicode(self):
2187
user = osutils.getuser_unicode()
2188
self.assertIsInstance(user, text_type)
2190
def envvar_to_override(self):
2191
if sys.platform == "win32":
2192
# Disable use of platform calls on windows so envvar is used
2193
self.overrideAttr(win32utils, 'has_ctypes', False)
2194
return 'USERNAME' # only variable used on windows
2195
return 'LOGNAME' # first variable checked by getpass.getuser()
2197
def test_ascii_user(self):
2198
self.overrideEnv(self.envvar_to_override(), 'jrandom')
2199
self.assertEqual(u'jrandom', osutils.getuser_unicode())
2201
def test_unicode_user(self):
2202
ue = osutils.get_user_encoding()
2203
uni_val, env_val = tests.probe_unicode_in_user_encoding()
2205
raise tests.TestSkipped(
2206
'Cannot find a unicode character that works in encoding %s'
2207
% (osutils.get_user_encoding(),))
2208
uni_username = u'jrandom' + uni_val
2209
encoded_username = uni_username.encode(ue)
2210
self.overrideEnv(self.envvar_to_override(), encoded_username)
2211
self.assertEqual(uni_username, osutils.getuser_unicode())
2214
class TestBackupNames(tests.TestCase):
2217
super(TestBackupNames, self).setUp()
2220
def backup_exists(self, name):
2221
return name in self.backups
2223
def available_backup_name(self, name):
2224
backup_name = osutils.available_backup_name(name, self.backup_exists)
2225
self.backups.append(backup_name)
2228
def assertBackupName(self, expected, name):
2229
self.assertEqual(expected, self.available_backup_name(name))
2231
def test_empty(self):
2232
self.assertBackupName('file.~1~', 'file')
2234
def test_existing(self):
2235
self.available_backup_name('file')
2236
self.available_backup_name('file')
2237
self.assertBackupName('file.~3~', 'file')
2238
# Empty slots are found, this is not a strict requirement and may be
2239
# revisited if we test against all implementations.
2240
self.backups.remove('file.~2~')
2241
self.assertBackupName('file.~2~', 'file')
2244
class TestFindExecutableInPath(tests.TestCase):
2246
def test_windows(self):
2247
if sys.platform != 'win32':
2248
raise tests.TestSkipped('test requires win32')
2249
self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
2251
osutils.find_executable_on_path('explorer.exe') is not None)
2253
osutils.find_executable_on_path('EXPLORER.EXE') is not None)
2255
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2256
self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2258
def test_windows_app_path(self):
2259
if sys.platform != 'win32':
2260
raise tests.TestSkipped('test requires win32')
2261
# Override PATH env var so that exe can only be found on App Path
2262
self.overrideEnv('PATH', '')
2263
# Internt Explorer is always registered in the App Path
2264
self.assertTrue(osutils.find_executable_on_path('iexplore') is not None)
2266
def test_other(self):
2267
if sys.platform == 'win32':
2268
raise tests.TestSkipped('test requires non-win32')
2269
self.assertTrue(osutils.find_executable_on_path('sh') is not None)
2271
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2274
class TestEnvironmentErrors(tests.TestCase):
2275
"""Test handling of environmental errors"""
2277
def test_is_oserror(self):
2278
self.assertTrue(osutils.is_environment_error(
2279
OSError(errno.EINVAL, "Invalid parameter")))
2281
def test_is_ioerror(self):
2282
self.assertTrue(osutils.is_environment_error(
2283
IOError(errno.EINVAL, "Invalid parameter")))
2285
def test_is_socket_error(self):
2286
self.assertTrue(osutils.is_environment_error(
2287
socket.error(errno.EINVAL, "Invalid parameter")))
2289
def test_is_select_error(self):
2290
self.assertTrue(osutils.is_environment_error(
2291
select.error(errno.EINVAL, "Invalid parameter")))
2293
def test_is_pywintypes_error(self):
2294
self.requireFeature(features.pywintypes)
2296
self.assertTrue(osutils.is_environment_error(
2297
pywintypes.error(errno.EINVAL, "Invalid parameter", "Caller")))