13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""Tests for the osutils wrapper."""
19
from cStringIO import StringIO
28
26
from bzrlib import (
31
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
32
from bzrlib.osutils import (
34
is_inside_or_parent_of_any,
35
38
from bzrlib.tests import (
39
probe_unicode_in_user_encoding,
46
from bzrlib.tests.file_utils import (
42
class _UTF8DirReaderFeature(tests.Feature):
46
from bzrlib import _readdir_pyx
47
self.reader = _readdir_pyx.UTF8DirReader
52
def feature_name(self):
53
return 'bzrlib._readdir_pyx'
55
UTF8DirReaderFeature = _UTF8DirReaderFeature()
57
term_ios_feature = tests.ModuleAvailableFeature('termios')
60
def _already_unicode(s):
64
def _utf8_to_unicode(s):
65
return s.decode('UTF-8')
68
def dir_reader_scenarios():
69
# For each dir reader we define:
71
# - native_to_unicode: a function converting the native_abspath as returned
72
# by DirReader.read_dir to its unicode representation
74
# UnicodeDirReader is the fallback, it should be tested on all platforms.
75
scenarios = [('unicode',
76
dict(_dir_reader_class=osutils.UnicodeDirReader,
77
_native_to_unicode=_already_unicode))]
78
# Some DirReaders are platform specific and even there they may not be
80
if UTF8DirReaderFeature.available():
81
from bzrlib import _readdir_pyx
82
scenarios.append(('utf8',
83
dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
84
_native_to_unicode=_utf8_to_unicode)))
86
if test__walkdirs_win32.win32_readdir_feature.available():
88
from bzrlib import _walkdirs_win32
91
dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
92
_native_to_unicode=_already_unicode)))
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)
107
class TestContainsWhitespace(tests.TestCase):
49
from cStringIO import StringIO
51
class TestOSUtils(TestCaseInTempDir):
109
53
def test_contains_whitespace(self):
110
54
self.failUnless(osutils.contains_whitespace(u' '))
120
64
self.failIf(osutils.contains_whitespace(u'hellothere'))
121
65
self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
124
class TestRename(tests.TestCaseInTempDir):
126
def create_file(self, filename, content):
127
f = open(filename, 'wb')
133
def _fancy_rename(self, a, b):
134
osutils.fancy_rename(a, b, rename_func=os.rename,
135
unlink_func=os.unlink)
137
67
def test_fancy_rename(self):
138
68
# This should work everywhere
139
self.create_file('a', 'something in a\n')
140
self._fancy_rename('a', 'b')
70
osutils.fancy_rename(a, b,
71
rename_func=os.rename,
72
unlink_func=os.unlink)
74
open('a', 'wb').write('something in a\n')
141
76
self.failIfExists('a')
142
77
self.failUnlessExists('b')
143
78
self.check_file_contents('b', 'something in a\n')
145
self.create_file('a', 'new something in a\n')
146
self._fancy_rename('b', 'a')
80
open('a', 'wb').write('new something in a\n')
148
83
self.check_file_contents('a', 'something in a\n')
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')
158
def test_fancy_rename_fails_if_source_and_target_missing(self):
159
self.assertRaises((IOError, OSError), self._fancy_rename,
160
'missingsource', 'missingtarget')
162
85
def test_rename(self):
163
86
# Rename should be semi-atomic on all platforms
164
self.create_file('a', 'something in a\n')
87
open('a', 'wb').write('something in a\n')
165
88
osutils.rename('a', 'b')
166
89
self.failIfExists('a')
167
90
self.failUnlessExists('b')
168
91
self.check_file_contents('b', 'something in a\n')
170
self.create_file('a', 'new something in a\n')
93
open('a', 'wb').write('new something in a\n')
171
94
osutils.rename('b', 'a')
173
96
self.check_file_contents('a', 'something in a\n')
468
316
osutils.make_readonly('dangling')
469
317
osutils.make_writable('dangling')
319
def test_kind_marker(self):
320
self.assertEqual("", osutils.kind_marker("file"))
321
self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
322
self.assertEqual("@", osutils.kind_marker("symlink"))
323
self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
471
325
def test_host_os_dereferences_symlinks(self):
472
326
osutils.host_os_dereferences_symlinks()
475
class TestCanonicalRelPath(tests.TestCaseInTempDir):
477
_test_needs_features = [tests.CaseInsCasePresFilenameFeature]
479
def test_canonical_relpath_simple(self):
480
f = file('MixedCaseName', 'w')
482
actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
483
self.failUnlessEqual('work/MixedCaseName', actual)
485
def test_canonical_relpath_missing_tail(self):
486
os.mkdir('MixedCaseParent')
487
actual = osutils.canonical_relpath(self.test_base_dir,
488
'mixedcaseparent/nochild')
489
self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
492
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
494
def assertRelpath(self, expected, base, path):
495
actual = osutils._cicp_canonical_relpath(base, path)
496
self.assertEqual(expected, actual)
498
def test_simple(self):
499
self.build_tree(['MixedCaseName'])
500
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
501
self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
503
def test_subdir_missing_tail(self):
504
self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
505
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
506
self.assertRelpath('MixedCaseParent/a_child', base,
507
'MixedCaseParent/a_child')
508
self.assertRelpath('MixedCaseParent/a_child', base,
509
'MixedCaseParent/A_Child')
510
self.assertRelpath('MixedCaseParent/not_child', base,
511
'MixedCaseParent/not_child')
513
def test_at_root_slash(self):
514
# We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
516
if osutils.MIN_ABS_PATHLENGTH > 1:
517
raise tests.TestSkipped('relpath requires %d chars'
518
% osutils.MIN_ABS_PATHLENGTH)
519
self.assertRelpath('foo', '/', '/foo')
521
def test_at_root_drive(self):
522
if sys.platform != 'win32':
523
raise tests.TestNotApplicable('we can only test drive-letter relative'
524
' paths on Windows where we have drive'
527
# The specific issue is that when at the root of a drive, 'abspath'
528
# returns "C:/" or just "/". However, the code assumes that abspath
529
# always returns something like "C:/foo" or "/foo" (no trailing slash).
530
self.assertRelpath('foo', 'C:/', 'C:/foo')
531
self.assertRelpath('foo', 'X:/', 'X:/foo')
532
self.assertRelpath('foo', 'X:/', 'X://foo')
535
class TestPumpFile(tests.TestCase):
329
class TestPumpFile(TestCase):
536
330
"""Test pumpfile method."""
539
tests.TestCase.setUp(self)
540
332
# create a test datablock
541
333
self.block_size = 512
542
334
pattern = '0123456789ABCDEF'
645
436
message = "Data not equal. Expected %d bytes, received %d."
646
437
self.fail(message % (len(response_data), self.test_data_len))
648
def test_report_activity(self):
650
def log_activity(length, direction):
651
activity.append((length, direction))
652
from_file = StringIO(self.test_data)
654
osutils.pumpfile(from_file, to_file, buff_size=500,
655
report_activity=log_activity, direction='read')
656
self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
657
(36, 'read')], activity)
659
from_file = StringIO(self.test_data)
662
osutils.pumpfile(from_file, to_file, buff_size=500,
663
report_activity=log_activity, direction='write')
664
self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
665
(36, 'write')], activity)
667
# And with a limited amount of data
668
from_file = StringIO(self.test_data)
671
osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
672
report_activity=log_activity, direction='read')
673
self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
677
class TestPumpStringFile(tests.TestCase):
679
def test_empty(self):
681
osutils.pump_string_file("", output)
682
self.assertEqual("", output.getvalue())
684
def test_more_than_segment_size(self):
686
osutils.pump_string_file("123456789", output, 2)
687
self.assertEqual("123456789", output.getvalue())
689
def test_segment_size(self):
691
osutils.pump_string_file("12", output, 2)
692
self.assertEqual("12", output.getvalue())
694
def test_segment_size_multiple(self):
696
osutils.pump_string_file("1234", output, 2)
697
self.assertEqual("1234", output.getvalue())
700
class TestRelpath(tests.TestCase):
702
def test_simple_relpath(self):
703
cwd = osutils.getcwd()
704
subdir = cwd + '/subdir'
705
self.assertEqual('subdir', osutils.relpath(cwd, subdir))
707
def test_deep_relpath(self):
708
cwd = osutils.getcwd()
709
subdir = cwd + '/sub/subsubdir'
710
self.assertEqual('sub/subsubdir', osutils.relpath(cwd, subdir))
712
def test_not_relative(self):
713
self.assertRaises(errors.PathNotChild,
714
osutils.relpath, 'C:/path', 'H:/path')
715
self.assertRaises(errors.PathNotChild,
716
osutils.relpath, 'C:/', 'H:/path')
719
class TestSafeUnicode(tests.TestCase):
439
class TestSafeUnicode(TestCase):
721
441
def test_from_ascii_string(self):
722
442
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
963
677
self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
966
class TestParentDirectories(tests.TestCaseInTempDir):
967
"""Test osutils.parent_directories()"""
969
def test_parent_directories(self):
970
self.assertEqual([], osutils.parent_directories('a'))
971
self.assertEqual(['a'], osutils.parent_directories('a/b'))
972
self.assertEqual(['a/b', 'a'], osutils.parent_directories('a/b/c'))
975
class TestMacFuncsDirs(tests.TestCaseInTempDir):
680
class TestMacFuncsDirs(TestCaseInTempDir):
976
681
"""Test mac special functions that require directories."""
978
683
def test_getcwd(self):
979
self.requireFeature(tests.UnicodeFilenameFeature)
980
os.mkdir(u'B\xe5gfors')
684
# On Mac, this will actually create Ba\u030agfors
685
# but chdir will still work, because it accepts both paths
687
os.mkdir(u'B\xe5gfors')
689
raise TestSkipped("Unable to create Unicode filename")
981
691
os.chdir(u'B\xe5gfors')
982
692
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
984
694
def test_getcwd_nonnorm(self):
985
self.requireFeature(tests.UnicodeFilenameFeature)
986
695
# Test that _mac_getcwd() will normalize this path
987
os.mkdir(u'Ba\u030agfors')
697
os.mkdir(u'Ba\u030agfors')
699
raise TestSkipped("Unable to create Unicode filename")
988
701
os.chdir(u'Ba\u030agfors')
989
702
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
992
class TestChunksToLines(tests.TestCase):
994
def test_smoketest(self):
995
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
996
osutils.chunks_to_lines(['foo\nbar', '\nbaz\n']))
997
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
998
osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
1000
def test_osutils_binding(self):
1001
from bzrlib.tests import test__chunks_to_lines
1002
if test__chunks_to_lines.compiled_chunkstolines_feature.available():
1003
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1005
from bzrlib._chunks_to_lines_py import chunks_to_lines
1006
self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
1009
class TestSplitLines(tests.TestCase):
705
class TestSplitLines(TestCase):
1011
707
def test_split_unicode(self):
1012
708
self.assertEqual([u'foo\n', u'bar\xae'],
1144
818
new_dirblock.append((info[0], info[1], info[2], info[4]))
1145
819
dirblock[:] = new_dirblock
1147
def _save_platform_info(self):
1148
self.overrideAttr(win32utils, 'winver')
1149
self.overrideAttr(osutils, '_fs_enc')
1150
self.overrideAttr(osutils, '_selected_dir_reader')
1152
def assertDirReaderIs(self, expected):
1153
"""Assert the right implementation for _walkdirs_utf8 is chosen."""
1154
# Force it to redetect
1155
osutils._selected_dir_reader = None
1156
# Nothing to list, but should still trigger the selection logic
1157
self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
1158
self.assertIsInstance(osutils._selected_dir_reader, expected)
1160
def test_force_walkdirs_utf8_fs_utf8(self):
1161
self.requireFeature(UTF8DirReaderFeature)
1162
self._save_platform_info()
1163
win32utils.winver = None # Avoid the win32 detection code
1164
osutils._fs_enc = 'UTF-8'
1165
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1167
def test_force_walkdirs_utf8_fs_ascii(self):
1168
self.requireFeature(UTF8DirReaderFeature)
1169
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)
1181
def test_force_walkdirs_utf8_fs_latin1(self):
1182
self._save_platform_info()
1183
win32utils.winver = None # Avoid the win32 detection code
1184
osutils._fs_enc = 'latin1'
1185
self.assertDirReaderIs(osutils.UnicodeDirReader)
1187
def test_force_walkdirs_utf8_nt(self):
1188
# Disabled because the thunk of the whole walkdirs api is disabled.
1189
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1190
self._save_platform_info()
1191
win32utils.winver = 'Windows NT'
1192
from bzrlib._walkdirs_win32 import Win32ReadDir
1193
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
821
def test_unicode_walkdirs(self):
1202
822
"""Walkdirs should always return unicode paths."""
1203
self.requireFeature(tests.UnicodeFilenameFeature)
1204
823
name0 = u'0file-\xb6'
1205
824
name1 = u'1dir-\u062c\u0648'
1206
825
name2 = u'2file-\u0633'
1299
925
result.append((dirdetail, new_dirblock))
1300
926
self.assertEqual(expected_dirblocks, result)
1302
def test__walkdirs_utf8_with_unicode_fs(self):
1303
"""UnicodeDirReader should be a safe fallback everywhere
928
def test_unicode__walkdirs_unicode_to_utf8(self):
929
"""walkdirs_unicode_to_utf8 should be a safe fallback everywhere
1305
931
The abspath portion should be in unicode
1307
self.requireFeature(tests.UnicodeFilenameFeature)
1308
# Use the unicode reader. TODO: split into driver-and-driven unit
1310
self._save_platform_info()
1311
osutils._selected_dir_reader = osutils.UnicodeDirReader()
1312
name0u = u'0file-\xb6'
1313
name1u = u'1dir-\u062c\u0648'
1314
name2u = u'2file-\u0633'
1318
name1u + '/' + name0u,
1319
name1u + '/' + name1u + '/',
1322
self.build_tree(tree)
1323
name0 = name0u.encode('utf8')
1324
name1 = name1u.encode('utf8')
1325
name2 = name2u.encode('utf8')
1327
# All of the abspaths should be in unicode, all of the relative paths
1329
expected_dirblocks = [
1331
[(name0, name0, 'file', './' + name0u),
1332
(name1, name1, 'directory', './' + name1u),
1333
(name2, name2, 'file', './' + name2u),
1336
((name1, './' + name1u),
1337
[(name1 + '/' + name0, name0, 'file', './' + name1u
1339
(name1 + '/' + name1, name1, 'directory', './' + name1u
1343
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1348
result = list(osutils._walkdirs_utf8('.'))
1349
self._filter_out_stat(result)
1350
self.assertEqual(expected_dirblocks, result)
1352
def test__walkdirs_utf8_win32readdir(self):
1353
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1354
self.requireFeature(tests.UnicodeFilenameFeature)
1355
from bzrlib._walkdirs_win32 import Win32ReadDir
1356
self._save_platform_info()
1357
osutils._selected_dir_reader = Win32ReadDir()
1358
name0u = u'0file-\xb6'
1359
name1u = u'1dir-\u062c\u0648'
1360
name2u = u'2file-\u0633'
1364
name1u + '/' + name0u,
1365
name1u + '/' + name1u + '/',
1368
self.build_tree(tree)
1369
name0 = name0u.encode('utf8')
1370
name1 = name1u.encode('utf8')
1371
name2 = name2u.encode('utf8')
1373
# All of the abspaths should be in unicode, all of the relative paths
1375
expected_dirblocks = [
1377
[(name0, name0, 'file', './' + name0u),
1378
(name1, name1, 'directory', './' + name1u),
1379
(name2, name2, 'file', './' + name2u),
1382
((name1, './' + name1u),
1383
[(name1 + '/' + name0, name0, 'file', './' + name1u
1385
(name1 + '/' + name1, name1, 'directory', './' + name1u
1389
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1394
result = list(osutils._walkdirs_utf8(u'.'))
1395
self._filter_out_stat(result)
1396
self.assertEqual(expected_dirblocks, result)
1398
def assertStatIsCorrect(self, path, win32stat):
1399
os_stat = os.stat(path)
1400
self.assertEqual(os_stat.st_size, win32stat.st_size)
1401
self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
1402
self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
1403
self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
1404
self.assertEqual(os_stat.st_dev, win32stat.st_dev)
1405
self.assertEqual(os_stat.st_ino, win32stat.st_ino)
1406
self.assertEqual(os_stat.st_mode, win32stat.st_mode)
1408
def test__walkdirs_utf_win32_find_file_stat_file(self):
1409
"""make sure our Stat values are valid"""
1410
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1411
self.requireFeature(tests.UnicodeFilenameFeature)
1412
from bzrlib._walkdirs_win32 import Win32ReadDir
1413
name0u = u'0file-\xb6'
1414
name0 = name0u.encode('utf8')
1415
self.build_tree([name0u])
1416
# I hate to sleep() here, but I'm trying to make the ctime different
1419
f = open(name0u, 'ab')
933
name0u = u'0file-\xb6'
934
name1u = u'1dir-\u062c\u0648'
935
name2u = u'2file-\u0633'
939
name1u + '/' + name0u,
940
name1u + '/' + name1u + '/',
1421
f.write('just a small update')
1425
result = Win32ReadDir().read_dir('', u'.')
1427
self.assertEqual((name0, name0, 'file'), entry[:3])
1428
self.assertEqual(u'./' + name0u, entry[4])
1429
self.assertStatIsCorrect(entry[4], entry[3])
1430
self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
1432
def test__walkdirs_utf_win32_find_file_stat_directory(self):
1433
"""make sure our Stat values are valid"""
1434
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1435
self.requireFeature(tests.UnicodeFilenameFeature)
1436
from bzrlib._walkdirs_win32 import Win32ReadDir
1437
name0u = u'0dir-\u062c\u0648'
944
self.build_tree(tree)
946
raise TestSkipped('Could not represent Unicode chars'
947
' in current encoding.')
1438
948
name0 = name0u.encode('utf8')
1439
self.build_tree([name0u + '/'])
949
name1 = name1u.encode('utf8')
950
name2 = name2u.encode('utf8')
1441
result = Win32ReadDir().read_dir('', u'.')
1443
self.assertEqual((name0, name0, 'directory'), entry[:3])
1444
self.assertEqual(u'./' + name0u, entry[4])
1445
self.assertStatIsCorrect(entry[4], entry[3])
952
# All of the abspaths should be in unicode, all of the relative paths
954
expected_dirblocks = [
956
[(name0, name0, 'file', './' + name0u),
957
(name1, name1, 'directory', './' + name1u),
958
(name2, name2, 'file', './' + name2u),
961
((name1, './' + name1u),
962
[(name1 + '/' + name0, name0, 'file', './' + name1u
964
(name1 + '/' + name1, name1, 'directory', './' + name1u
968
((name1 + '/' + name1, './' + name1u + '/' + name1u),
973
result = list(osutils._walkdirs_unicode_to_utf8('.'))
974
self._filter_out_stat(result)
975
self.assertEqual(expected_dirblocks, result)
1447
977
def assertPathCompare(self, path_less, path_greater):
1448
978
"""check that path_less and path_greater compare correctly."""
1624
1158
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1627
class TestSizeShaFile(tests.TestCaseInTempDir):
1629
def test_sha_empty(self):
1630
self.build_tree_contents([('foo', '')])
1631
expected_sha = osutils.sha_string('')
1633
self.addCleanup(f.close)
1634
size, sha = osutils.size_sha_file(f)
1635
self.assertEqual(0, size)
1636
self.assertEqual(expected_sha, sha)
1638
def test_sha_mixed_endings(self):
1639
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1640
self.build_tree_contents([('foo', text)])
1641
expected_sha = osutils.sha_string(text)
1642
f = open('foo', 'rb')
1643
self.addCleanup(f.close)
1644
size, sha = osutils.size_sha_file(f)
1645
self.assertEqual(38, size)
1646
self.assertEqual(expected_sha, sha)
1649
class TestShaFileByName(tests.TestCaseInTempDir):
1651
def test_sha_empty(self):
1652
self.build_tree_contents([('foo', '')])
1653
expected_sha = osutils.sha_string('')
1654
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1656
def test_sha_mixed_endings(self):
1657
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1658
self.build_tree_contents([('foo', text)])
1659
expected_sha = osutils.sha_string(text)
1660
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1663
class TestResourceLoading(tests.TestCaseInTempDir):
1161
class TestLocalTimeOffset(TestCase):
1163
def test_local_time_offset(self):
1164
"""Test that local_time_offset() returns a sane value."""
1165
offset = osutils.local_time_offset()
1166
self.assertTrue(isinstance(offset, int))
1167
# Test that the offset is no more than a eighteen hours in
1169
# Time zone handling is system specific, so it is difficult to
1170
# do more specific tests, but a value outside of this range is
1172
eighteen_hours = 18 * 3600
1173
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1175
def test_local_time_offset_with_timestamp(self):
1176
"""Test that local_time_offset() works with a timestamp."""
1177
offset = osutils.local_time_offset(1000000000.1234567)
1178
self.assertTrue(isinstance(offset, int))
1179
eighteen_hours = 18 * 3600
1180
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1183
class TestShaFileByName(TestCaseInTempDir):
1185
def test_sha_empty(self):
1186
self.build_tree_contents([('foo', '')])
1187
expected_sha = osutils.sha_string('')
1188
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1190
def test_sha_mixed_endings(self):
1191
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1192
self.build_tree_contents([('foo', text)])
1193
expected_sha = osutils.sha_string(text)
1194
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1198
r'''# Copyright (C) 2005, 2006 Canonical Ltd
1200
# This program is free software; you can redistribute it and/or modify
1201
# it under the terms of the GNU General Public License as published by
1202
# the Free Software Foundation; either version 2 of the License, or
1203
# (at your option) any later version.
1205
# This program is distributed in the hope that it will be useful,
1206
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1207
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1208
# GNU General Public License for more details.
1210
# You should have received a copy of the GNU General Public License
1211
# along with this program; if not, write to the Free Software
1212
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1215
# NOTE: If update these, please also update the help for global-options in
1216
# bzrlib/help_topics/__init__.py
1219
"""Set of flags that enable different debug behaviour.
1221
These are set with eg ``-Dlock`` on the bzr command line.
1225
* auth - show authentication sections used
1226
* error - show stack traces for all top level exceptions
1227
* evil - capture call sites that do expensive or badly-scaling operations.
1228
* fetch - trace history copying between repositories
1229
* graph - trace graph traversal information
1230
* hashcache - log every time a working file is read to determine its hash
1231
* hooks - trace hook execution
1232
* hpss - trace smart protocol requests and responses
1233
* http - trace http connections, requests and responses
1234
* index - trace major index operations
1235
* knit - trace knit operations
1236
* lock - trace when lockdir locks are taken or released
1237
* merge - emit information for debugging merges
1238
* pack - emit information about pack operations
1244
class TestResourceLoading(TestCaseInTempDir):
1665
1246
def test_resource_string(self):
1666
1247
# test resource in bzrlib
1667
1248
text = osutils.resource_string('bzrlib', 'debug.py')
1668
self.assertContainsRe(text, "debug_flags = set()")
1249
self.assertEquals(_debug_text, text)
1669
1250
# test resource under bzrlib
1670
1251
text = osutils.resource_string('bzrlib.ui', 'text.py')
1671
1252
self.assertContainsRe(text, "class TextUIFactory")
1675
1256
# test unknown resource
1676
1257
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",
1697
class TestDirReader(tests.TestCaseInTempDir):
1700
_dir_reader_class = None
1701
_native_to_unicode = None
1704
tests.TestCaseInTempDir.setUp(self)
1705
self.overrideAttr(osutils,
1706
'_selected_dir_reader', self._dir_reader_class())
1708
def _get_ascii_tree(self):
1716
expected_dirblocks = [
1718
[('0file', '0file', 'file'),
1719
('1dir', '1dir', 'directory'),
1720
('2file', '2file', 'file'),
1723
(('1dir', './1dir'),
1724
[('1dir/0file', '0file', 'file'),
1725
('1dir/1dir', '1dir', 'directory'),
1728
(('1dir/1dir', './1dir/1dir'),
1733
return tree, expected_dirblocks
1735
def test_walk_cur_dir(self):
1736
tree, expected_dirblocks = self._get_ascii_tree()
1737
self.build_tree(tree)
1738
result = list(osutils._walkdirs_utf8('.'))
1739
# Filter out stat and abspath
1740
self.assertEqual(expected_dirblocks,
1741
[(dirinfo, [line[0:3] for line in block])
1742
for dirinfo, block in result])
1744
def test_walk_sub_dir(self):
1745
tree, expected_dirblocks = self._get_ascii_tree()
1746
self.build_tree(tree)
1747
# you can search a subdir only, with a supplied prefix.
1748
result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1749
# Filter out stat and abspath
1750
self.assertEqual(expected_dirblocks[1:],
1751
[(dirinfo, [line[0:3] for line in block])
1752
for dirinfo, block in result])
1754
def _get_unicode_tree(self):
1755
name0u = u'0file-\xb6'
1756
name1u = u'1dir-\u062c\u0648'
1757
name2u = u'2file-\u0633'
1761
name1u + '/' + name0u,
1762
name1u + '/' + name1u + '/',
1765
name0 = name0u.encode('UTF-8')
1766
name1 = name1u.encode('UTF-8')
1767
name2 = name2u.encode('UTF-8')
1768
expected_dirblocks = [
1770
[(name0, name0, 'file', './' + name0u),
1771
(name1, name1, 'directory', './' + name1u),
1772
(name2, name2, 'file', './' + name2u),
1775
((name1, './' + name1u),
1776
[(name1 + '/' + name0, name0, 'file', './' + name1u
1778
(name1 + '/' + name1, name1, 'directory', './' + name1u
1782
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1787
return tree, expected_dirblocks
1789
def _filter_out(self, raw_dirblocks):
1790
"""Filter out a walkdirs_utf8 result.
1792
stat field is removed, all native paths are converted to unicode
1794
filtered_dirblocks = []
1795
for dirinfo, block in raw_dirblocks:
1796
dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1799
details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1800
filtered_dirblocks.append((dirinfo, details))
1801
return filtered_dirblocks
1803
def test_walk_unicode_tree(self):
1804
self.requireFeature(tests.UnicodeFilenameFeature)
1805
tree, expected_dirblocks = self._get_unicode_tree()
1806
self.build_tree(tree)
1807
result = list(osutils._walkdirs_utf8('.'))
1808
self.assertEqual(expected_dirblocks, self._filter_out(result))
1810
def test_symlink(self):
1811
self.requireFeature(tests.SymlinkFeature)
1812
self.requireFeature(tests.UnicodeFilenameFeature)
1813
target = u'target\N{Euro Sign}'
1814
link_name = u'l\N{Euro Sign}nk'
1815
os.symlink(target, link_name)
1816
target_utf8 = target.encode('UTF-8')
1817
link_name_utf8 = link_name.encode('UTF-8')
1818
expected_dirblocks = [
1820
[(link_name_utf8, link_name_utf8,
1821
'symlink', './' + link_name),],
1823
result = list(osutils._walkdirs_utf8('.'))
1824
self.assertEqual(expected_dirblocks, self._filter_out(result))
1827
class TestReadLink(tests.TestCaseInTempDir):
1828
"""Exposes os.readlink() problems and the osutils solution.
1830
The only guarantee offered by os.readlink(), starting with 2.6, is that a
1831
unicode string will be returned if a unicode string is passed.
1833
But prior python versions failed to properly encode the passed unicode
1836
_test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
1839
super(tests.TestCaseInTempDir, self).setUp()
1840
self.link = u'l\N{Euro Sign}ink'
1841
self.target = u'targe\N{Euro Sign}t'
1842
os.symlink(self.target, self.link)
1844
def test_os_readlink_link_encoding(self):
1845
if sys.version_info < (2, 6):
1846
self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
1848
self.assertEquals(self.target, os.readlink(self.link))
1850
def test_os_readlink_link_decoding(self):
1851
self.assertEquals(self.target.encode(osutils._fs_enc),
1852
os.readlink(self.link.encode(osutils._fs_enc)))
1855
class TestConcurrency(tests.TestCase):
1858
super(TestConcurrency, self).setUp()
1859
self.overrideAttr(osutils, '_cached_local_concurrency')
1861
def test_local_concurrency(self):
1862
concurrency = osutils.local_concurrency()
1863
self.assertIsInstance(concurrency, int)
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))
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))
1881
class TestFailedToLoadExtension(tests.TestCase):
1883
def _try_loading(self):
1885
import bzrlib._fictional_extension_py
1886
except ImportError, e:
1887
osutils.failed_to_load_extension(e)
1891
super(TestFailedToLoadExtension, self).setUp()
1892
self.overrideAttr(osutils, '_extension_load_failures', [])
1894
def test_failure_to_load(self):
1896
self.assertLength(1, osutils._extension_load_failures)
1897
self.assertEquals(osutils._extension_load_failures[0],
1898
"No module named _fictional_extension_py")
1900
def test_report_extension_load_failures_no_warning(self):
1901
self.assertTrue(self._try_loading())
1902
warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
1903
# it used to give a Python warning; it no longer does
1904
self.assertLength(0, warnings)
1906
def test_report_extension_load_failures_message(self):
1908
trace.push_log_file(log)
1909
self.assertTrue(self._try_loading())
1910
osutils.report_extension_load_failures()
1911
self.assertContainsRe(
1913
r"bzr: warning: some compiled extensions could not be loaded; "
1914
"see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1918
class TestTerminalWidth(tests.TestCase):
1920
def replace_stdout(self, new):
1921
self.overrideAttr(sys, 'stdout', new)
1923
def replace__terminal_size(self, new):
1924
self.overrideAttr(osutils, '_terminal_size', new)
1926
def set_fake_tty(self):
1928
class I_am_a_tty(object):
1932
self.replace_stdout(I_am_a_tty())
1934
def test_default_values(self):
1935
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'
1941
self.assertEqual(12, osutils.terminal_width())
1943
def test_falls_back_to_COLUMNS(self):
1944
del os.environ['BZR_COLUMNS']
1945
self.assertNotEqual('42', os.environ['COLUMNS'])
1947
os.environ['COLUMNS'] = '42'
1948
self.assertEqual(42, osutils.terminal_width())
1950
def test_tty_default_without_columns(self):
1951
del os.environ['BZR_COLUMNS']
1952
del os.environ['COLUMNS']
1954
def terminal_size(w, h):
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())
1964
def test_non_tty_default_without_columns(self):
1965
del os.environ['BZR_COLUMNS']
1966
del os.environ['COLUMNS']
1967
self.replace_stdout(None)
1968
self.assertEqual(None, osutils.terminal_width())
1970
def test_no_TIOCGWINSZ(self):
1971
self.requireFeature(term_ios_feature)
1972
termios = term_ios_feature.module
1973
# bug 63539 is about a termios without TIOCGWINSZ attribute
1975
orig = termios.TIOCGWINSZ
1976
except AttributeError:
1977
# We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
1980
self.overrideAttr(termios, 'TIOCGWINSZ')
1981
del termios.TIOCGWINSZ
1982
del os.environ['BZR_COLUMNS']
1983
del os.environ['COLUMNS']
1984
# Whatever the result is, if we don't raise an exception, it's ok.
1985
osutils.terminal_width()
1987
class TestCreationOps(tests.TestCaseInTempDir):
1988
_test_needs_features = [features.chown_feature]
1991
tests.TestCaseInTempDir.setUp(self)
1992
self.overrideAttr(os, 'chown', self._dummy_chown)
1994
# params set by call to _dummy_chown
1995
self.path = self.uid = self.gid = None
1997
def _dummy_chown(self, path, uid, gid):
1998
self.path, self.uid, self.gid = path, uid, gid
2000
def test_copy_ownership_from_path(self):
2001
"""copy_ownership_from_path test with specified src."""
2003
f = open('test_file', 'wt')
2004
osutils.copy_ownership_from_path('test_file', ownsrc)
2007
self.assertEquals(self.path, 'test_file')
2008
self.assertEquals(self.uid, s.st_uid)
2009
self.assertEquals(self.gid, s.st_gid)
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')
2018
self.assertEquals(self.path, 'test_file')
2019
self.assertEquals(self.uid, s.st_uid)
2020
self.assertEquals(self.gid, s.st_gid)
added
removed
bzrlib/tests/test_osutils.py
