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
27
26
from bzrlib import (
31
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
32
from bzrlib.osutils import (
34
is_inside_or_parent_of_any,
36
37
from bzrlib.tests import (
41
from bzrlib.tests.scenarios import load_tests_apply_scenarios
44
class _UTF8DirReaderFeature(features.Feature):
48
from bzrlib import _readdir_pyx
49
self.reader = _readdir_pyx.UTF8DirReader
54
def feature_name(self):
55
return 'bzrlib._readdir_pyx'
57
UTF8DirReaderFeature = features.ModuleAvailableFeature('bzrlib._readdir_pyx')
59
term_ios_feature = features.ModuleAvailableFeature('termios')
62
def _already_unicode(s):
66
def _utf8_to_unicode(s):
67
return s.decode('UTF-8')
70
def dir_reader_scenarios():
71
# For each dir reader we define:
73
# - native_to_unicode: a function converting the native_abspath as returned
74
# by DirReader.read_dir to its unicode representation
76
# UnicodeDirReader is the fallback, it should be tested on all platforms.
77
scenarios = [('unicode',
78
dict(_dir_reader_class=osutils.UnicodeDirReader,
79
_native_to_unicode=_already_unicode))]
80
# Some DirReaders are platform specific and even there they may not be
82
if UTF8DirReaderFeature.available():
83
from bzrlib import _readdir_pyx
84
scenarios.append(('utf8',
85
dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
86
_native_to_unicode=_utf8_to_unicode)))
88
if test__walkdirs_win32.win32_readdir_feature.available():
90
from bzrlib import _walkdirs_win32
93
dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
94
_native_to_unicode=_already_unicode)))
100
load_tests = load_tests_apply_scenarios
103
class TestContainsWhitespace(tests.TestCase):
38
probe_unicode_in_user_encoding,
47
class TestOSUtils(TestCaseInTempDir):
105
49
def test_contains_whitespace(self):
106
self.assertTrue(osutils.contains_whitespace(u' '))
107
self.assertTrue(osutils.contains_whitespace(u'hello there'))
108
self.assertTrue(osutils.contains_whitespace(u'hellothere\n'))
109
self.assertTrue(osutils.contains_whitespace(u'hello\nthere'))
110
self.assertTrue(osutils.contains_whitespace(u'hello\rthere'))
111
self.assertTrue(osutils.contains_whitespace(u'hello\tthere'))
50
self.failUnless(osutils.contains_whitespace(u' '))
51
self.failUnless(osutils.contains_whitespace(u'hello there'))
52
self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
53
self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
54
self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
55
self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
113
57
# \xa0 is "Non-breaking-space" which on some python locales thinks it
114
58
# is whitespace, but we do not.
115
self.assertFalse(osutils.contains_whitespace(u''))
116
self.assertFalse(osutils.contains_whitespace(u'hellothere'))
117
self.assertFalse(osutils.contains_whitespace(u'hello\xa0there'))
120
class TestRename(tests.TestCaseInTempDir):
122
def create_file(self, filename, content):
123
f = open(filename, 'wb')
129
def _fancy_rename(self, a, b):
130
osutils.fancy_rename(a, b, rename_func=os.rename,
131
unlink_func=os.unlink)
59
self.failIf(osutils.contains_whitespace(u''))
60
self.failIf(osutils.contains_whitespace(u'hellothere'))
61
self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
133
63
def test_fancy_rename(self):
134
64
# This should work everywhere
135
self.create_file('a', 'something in a\n')
136
self._fancy_rename('a', 'b')
137
self.assertPathDoesNotExist('a')
138
self.assertPathExists('b')
66
osutils.fancy_rename(a, b,
67
rename_func=os.rename,
68
unlink_func=os.unlink)
70
open('a', 'wb').write('something in a\n')
72
self.failIfExists('a')
73
self.failUnlessExists('b')
139
74
self.check_file_contents('b', 'something in a\n')
141
self.create_file('a', 'new something in a\n')
142
self._fancy_rename('b', 'a')
76
open('a', 'wb').write('new something in a\n')
144
79
self.check_file_contents('a', 'something in a\n')
146
def test_fancy_rename_fails_source_missing(self):
147
# An exception should be raised, and the target should be left in place
148
self.create_file('target', 'data in target\n')
149
self.assertRaises((IOError, OSError), self._fancy_rename,
150
'missingsource', 'target')
151
self.assertPathExists('target')
152
self.check_file_contents('target', 'data in target\n')
154
def test_fancy_rename_fails_if_source_and_target_missing(self):
155
self.assertRaises((IOError, OSError), self._fancy_rename,
156
'missingsource', 'missingtarget')
158
81
def test_rename(self):
159
82
# Rename should be semi-atomic on all platforms
160
self.create_file('a', 'something in a\n')
83
open('a', 'wb').write('something in a\n')
161
84
osutils.rename('a', 'b')
162
self.assertPathDoesNotExist('a')
163
self.assertPathExists('b')
85
self.failIfExists('a')
86
self.failUnlessExists('b')
164
87
self.check_file_contents('b', 'something in a\n')
166
self.create_file('a', 'new something in a\n')
89
open('a', 'wb').write('new something in a\n')
167
90
osutils.rename('b', 'a')
169
92
self.check_file_contents('a', 'something in a\n')
476
312
osutils.make_readonly('dangling')
477
313
osutils.make_writable('dangling')
479
def test_host_os_dereferences_symlinks(self):
480
osutils.host_os_dereferences_symlinks()
483
class TestCanonicalRelPath(tests.TestCaseInTempDir):
485
_test_needs_features = [features.CaseInsCasePresFilenameFeature]
487
def test_canonical_relpath_simple(self):
488
f = file('MixedCaseName', 'w')
490
actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
491
self.assertEqual('work/MixedCaseName', actual)
493
def test_canonical_relpath_missing_tail(self):
494
os.mkdir('MixedCaseParent')
495
actual = osutils.canonical_relpath(self.test_base_dir,
496
'mixedcaseparent/nochild')
497
self.assertEqual('work/MixedCaseParent/nochild', actual)
500
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
502
def assertRelpath(self, expected, base, path):
503
actual = osutils._cicp_canonical_relpath(base, path)
504
self.assertEqual(expected, actual)
506
def test_simple(self):
507
self.build_tree(['MixedCaseName'])
508
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
509
self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
511
def test_subdir_missing_tail(self):
512
self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
513
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
514
self.assertRelpath('MixedCaseParent/a_child', base,
515
'MixedCaseParent/a_child')
516
self.assertRelpath('MixedCaseParent/a_child', base,
517
'MixedCaseParent/A_Child')
518
self.assertRelpath('MixedCaseParent/not_child', base,
519
'MixedCaseParent/not_child')
521
def test_at_root_slash(self):
522
# We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
524
if osutils.MIN_ABS_PATHLENGTH > 1:
525
raise tests.TestSkipped('relpath requires %d chars'
526
% osutils.MIN_ABS_PATHLENGTH)
527
self.assertRelpath('foo', '/', '/foo')
529
def test_at_root_drive(self):
530
if sys.platform != 'win32':
531
raise tests.TestNotApplicable('we can only test drive-letter relative'
532
' paths on Windows where we have drive'
535
# The specific issue is that when at the root of a drive, 'abspath'
536
# returns "C:/" or just "/". However, the code assumes that abspath
537
# always returns something like "C:/foo" or "/foo" (no trailing slash).
538
self.assertRelpath('foo', 'C:/', 'C:/foo')
539
self.assertRelpath('foo', 'X:/', 'X:/foo')
540
self.assertRelpath('foo', 'X:/', 'X://foo')
543
class TestPumpFile(tests.TestCase):
544
"""Test pumpfile method."""
547
tests.TestCase.setUp(self)
548
# create a test datablock
549
self.block_size = 512
550
pattern = '0123456789ABCDEF'
551
self.test_data = pattern * (3 * self.block_size / len(pattern))
552
self.test_data_len = len(self.test_data)
554
def test_bracket_block_size(self):
555
"""Read data in blocks with the requested read size bracketing the
557
# make sure test data is larger than max read size
558
self.assertTrue(self.test_data_len > self.block_size)
560
from_file = file_utils.FakeReadFile(self.test_data)
563
# read (max / 2) bytes and verify read size wasn't affected
564
num_bytes_to_read = self.block_size / 2
565
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
566
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
567
self.assertEqual(from_file.get_read_count(), 1)
569
# read (max) bytes and verify read size wasn't affected
570
num_bytes_to_read = self.block_size
571
from_file.reset_read_count()
572
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
573
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
574
self.assertEqual(from_file.get_read_count(), 1)
576
# read (max + 1) bytes and verify read size was limited
577
num_bytes_to_read = self.block_size + 1
578
from_file.reset_read_count()
579
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
580
self.assertEqual(from_file.get_max_read_size(), self.block_size)
581
self.assertEqual(from_file.get_read_count(), 2)
583
# finish reading the rest of the data
584
num_bytes_to_read = self.test_data_len - to_file.tell()
585
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
587
# report error if the data wasn't equal (we only report the size due
588
# to the length of the data)
589
response_data = to_file.getvalue()
590
if response_data != self.test_data:
591
message = "Data not equal. Expected %d bytes, received %d."
592
self.fail(message % (len(response_data), self.test_data_len))
594
def test_specified_size(self):
595
"""Request a transfer larger than the maximum block size and verify
596
that the maximum read doesn't exceed the block_size."""
597
# make sure test data is larger than max read size
598
self.assertTrue(self.test_data_len > self.block_size)
600
# retrieve data in blocks
601
from_file = file_utils.FakeReadFile(self.test_data)
603
osutils.pumpfile(from_file, to_file, self.test_data_len,
606
# verify read size was equal to the maximum read size
607
self.assertTrue(from_file.get_max_read_size() > 0)
608
self.assertEqual(from_file.get_max_read_size(), self.block_size)
609
self.assertEqual(from_file.get_read_count(), 3)
611
# report error if the data wasn't equal (we only report the size due
612
# to the length of the data)
613
response_data = to_file.getvalue()
614
if response_data != self.test_data:
615
message = "Data not equal. Expected %d bytes, received %d."
616
self.fail(message % (len(response_data), self.test_data_len))
618
def test_to_eof(self):
619
"""Read to end-of-file and verify that the reads are not larger than
620
the maximum read size."""
621
# make sure test data is larger than max read size
622
self.assertTrue(self.test_data_len > self.block_size)
624
# retrieve data to EOF
625
from_file = file_utils.FakeReadFile(self.test_data)
627
osutils.pumpfile(from_file, to_file, -1, self.block_size)
629
# verify read size was equal to the maximum read size
630
self.assertEqual(from_file.get_max_read_size(), self.block_size)
631
self.assertEqual(from_file.get_read_count(), 4)
633
# report error if the data wasn't equal (we only report the size due
634
# to the length of the data)
635
response_data = to_file.getvalue()
636
if response_data != self.test_data:
637
message = "Data not equal. Expected %d bytes, received %d."
638
self.fail(message % (len(response_data), self.test_data_len))
640
def test_defaults(self):
641
"""Verifies that the default arguments will read to EOF -- this
642
test verifies that any existing usages of pumpfile will not be broken
643
with this new version."""
644
# retrieve data using default (old) pumpfile method
645
from_file = file_utils.FakeReadFile(self.test_data)
647
osutils.pumpfile(from_file, to_file)
649
# report error if the data wasn't equal (we only report the size due
650
# to the length of the data)
651
response_data = to_file.getvalue()
652
if response_data != self.test_data:
653
message = "Data not equal. Expected %d bytes, received %d."
654
self.fail(message % (len(response_data), self.test_data_len))
656
def test_report_activity(self):
658
def log_activity(length, direction):
659
activity.append((length, direction))
660
from_file = StringIO(self.test_data)
662
osutils.pumpfile(from_file, to_file, buff_size=500,
663
report_activity=log_activity, direction='read')
664
self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
665
(36, 'read')], activity)
667
from_file = StringIO(self.test_data)
670
osutils.pumpfile(from_file, to_file, buff_size=500,
671
report_activity=log_activity, direction='write')
672
self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
673
(36, 'write')], activity)
675
# And with a limited amount of data
676
from_file = StringIO(self.test_data)
679
osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
680
report_activity=log_activity, direction='read')
681
self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
685
class TestPumpStringFile(tests.TestCase):
687
def test_empty(self):
689
osutils.pump_string_file("", output)
690
self.assertEqual("", output.getvalue())
692
def test_more_than_segment_size(self):
694
osutils.pump_string_file("123456789", output, 2)
695
self.assertEqual("123456789", output.getvalue())
697
def test_segment_size(self):
699
osutils.pump_string_file("12", output, 2)
700
self.assertEqual("12", output.getvalue())
702
def test_segment_size_multiple(self):
704
osutils.pump_string_file("1234", output, 2)
705
self.assertEqual("1234", output.getvalue())
708
class TestRelpath(tests.TestCase):
710
def test_simple_relpath(self):
711
cwd = osutils.getcwd()
712
subdir = cwd + '/subdir'
713
self.assertEqual('subdir', osutils.relpath(cwd, subdir))
715
def test_deep_relpath(self):
716
cwd = osutils.getcwd()
717
subdir = cwd + '/sub/subsubdir'
718
self.assertEqual('sub/subsubdir', osutils.relpath(cwd, subdir))
720
def test_not_relative(self):
721
self.assertRaises(errors.PathNotChild,
722
osutils.relpath, 'C:/path', 'H:/path')
723
self.assertRaises(errors.PathNotChild,
724
osutils.relpath, 'C:/', 'H:/path')
727
class TestSafeUnicode(tests.TestCase):
315
def test_kind_marker(self):
316
self.assertEqual("", osutils.kind_marker("file"))
317
self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
318
self.assertEqual("@", osutils.kind_marker("symlink"))
319
self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
322
class TestSafeUnicode(TestCase):
729
324
def test_from_ascii_string(self):
730
325
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
1357
808
result.append((dirdetail, new_dirblock))
1358
809
self.assertEqual(expected_dirblocks, result)
1360
def test__walkdirs_utf8_with_unicode_fs(self):
1361
"""UnicodeDirReader should be a safe fallback everywhere
811
def test_unicode__walkdirs_unicode_to_utf8(self):
812
"""walkdirs_unicode_to_utf8 should be a safe fallback everywhere
1363
814
The abspath portion should be in unicode
1365
self.requireFeature(features.UnicodeFilenameFeature)
1366
# Use the unicode reader. TODO: split into driver-and-driven unit
1368
self._save_platform_info()
1369
osutils._selected_dir_reader = osutils.UnicodeDirReader()
1370
name0u = u'0file-\xb6'
1371
name1u = u'1dir-\u062c\u0648'
1372
name2u = u'2file-\u0633'
1376
name1u + '/' + name0u,
1377
name1u + '/' + name1u + '/',
1380
self.build_tree(tree)
1381
name0 = name0u.encode('utf8')
1382
name1 = name1u.encode('utf8')
1383
name2 = name2u.encode('utf8')
1385
# All of the abspaths should be in unicode, all of the relative paths
1387
expected_dirblocks = [
1389
[(name0, name0, 'file', './' + name0u),
1390
(name1, name1, 'directory', './' + name1u),
1391
(name2, name2, 'file', './' + name2u),
1394
((name1, './' + name1u),
1395
[(name1 + '/' + name0, name0, 'file', './' + name1u
1397
(name1 + '/' + name1, name1, 'directory', './' + name1u
1401
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1406
result = list(osutils._walkdirs_utf8('.'))
1407
self._filter_out_stat(result)
1408
self.assertEqual(expected_dirblocks, result)
1410
def test__walkdirs_utf8_win32readdir(self):
1411
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1412
self.requireFeature(features.UnicodeFilenameFeature)
1413
from bzrlib._walkdirs_win32 import Win32ReadDir
1414
self._save_platform_info()
1415
osutils._selected_dir_reader = Win32ReadDir()
1416
name0u = u'0file-\xb6'
1417
name1u = u'1dir-\u062c\u0648'
1418
name2u = u'2file-\u0633'
1422
name1u + '/' + name0u,
1423
name1u + '/' + name1u + '/',
1426
self.build_tree(tree)
1427
name0 = name0u.encode('utf8')
1428
name1 = name1u.encode('utf8')
1429
name2 = name2u.encode('utf8')
1431
# All of the abspaths should be in unicode, all of the relative paths
1433
expected_dirblocks = [
1435
[(name0, name0, 'file', './' + name0u),
1436
(name1, name1, 'directory', './' + name1u),
1437
(name2, name2, 'file', './' + name2u),
1440
((name1, './' + name1u),
1441
[(name1 + '/' + name0, name0, 'file', './' + name1u
1443
(name1 + '/' + name1, name1, 'directory', './' + name1u
1447
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1452
result = list(osutils._walkdirs_utf8(u'.'))
1453
self._filter_out_stat(result)
1454
self.assertEqual(expected_dirblocks, result)
1456
def assertStatIsCorrect(self, path, win32stat):
1457
os_stat = os.stat(path)
1458
self.assertEqual(os_stat.st_size, win32stat.st_size)
1459
self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
1460
self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
1461
self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
1462
self.assertEqual(os_stat.st_dev, win32stat.st_dev)
1463
self.assertEqual(os_stat.st_ino, win32stat.st_ino)
1464
self.assertEqual(os_stat.st_mode, win32stat.st_mode)
1466
def test__walkdirs_utf_win32_find_file_stat_file(self):
1467
"""make sure our Stat values are valid"""
1468
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1469
self.requireFeature(features.UnicodeFilenameFeature)
1470
from bzrlib._walkdirs_win32 import Win32ReadDir
1471
name0u = u'0file-\xb6'
1472
name0 = name0u.encode('utf8')
1473
self.build_tree([name0u])
1474
# I hate to sleep() here, but I'm trying to make the ctime different
1477
f = open(name0u, 'ab')
816
name0u = u'0file-\xb6'
817
name1u = u'1dir-\u062c\u0648'
818
name2u = u'2file-\u0633'
822
name1u + '/' + name0u,
823
name1u + '/' + name1u + '/',
1479
f.write('just a small update')
1483
result = Win32ReadDir().read_dir('', u'.')
1485
self.assertEqual((name0, name0, 'file'), entry[:3])
1486
self.assertEqual(u'./' + name0u, entry[4])
1487
self.assertStatIsCorrect(entry[4], entry[3])
1488
self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
1490
def test__walkdirs_utf_win32_find_file_stat_directory(self):
1491
"""make sure our Stat values are valid"""
1492
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1493
self.requireFeature(features.UnicodeFilenameFeature)
1494
from bzrlib._walkdirs_win32 import Win32ReadDir
1495
name0u = u'0dir-\u062c\u0648'
827
self.build_tree(tree)
829
raise TestSkipped('Could not represent Unicode chars'
830
' in current encoding.')
1496
831
name0 = name0u.encode('utf8')
1497
self.build_tree([name0u + '/'])
832
name1 = name1u.encode('utf8')
833
name2 = name2u.encode('utf8')
1499
result = Win32ReadDir().read_dir('', u'.')
1501
self.assertEqual((name0, name0, 'directory'), entry[:3])
1502
self.assertEqual(u'./' + name0u, entry[4])
1503
self.assertStatIsCorrect(entry[4], entry[3])
835
# All of the abspaths should be in unicode, all of the relative paths
837
expected_dirblocks = [
839
[(name0, name0, 'file', './' + name0u),
840
(name1, name1, 'directory', './' + name1u),
841
(name2, name2, 'file', './' + name2u),
844
((name1, './' + name1u),
845
[(name1 + '/' + name0, name0, 'file', './' + name1u
847
(name1 + '/' + name1, name1, 'directory', './' + name1u
851
((name1 + '/' + name1, './' + name1u + '/' + name1u),
856
result = list(osutils._walkdirs_unicode_to_utf8('.'))
857
self._filter_out_stat(result)
858
self.assertEqual(expected_dirblocks, result)
1505
860
def assertPathCompare(self, path_less, path_greater):
1506
861
"""check that path_less and path_greater compare correctly."""
1679
1038
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1680
1039
self.assertEqual('foo', old)
1681
1040
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1682
self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
1685
class TestSizeShaFile(tests.TestCaseInTempDir):
1687
def test_sha_empty(self):
1688
self.build_tree_contents([('foo', '')])
1689
expected_sha = osutils.sha_string('')
1691
self.addCleanup(f.close)
1692
size, sha = osutils.size_sha_file(f)
1693
self.assertEqual(0, size)
1694
self.assertEqual(expected_sha, sha)
1696
def test_sha_mixed_endings(self):
1697
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1698
self.build_tree_contents([('foo', text)])
1699
expected_sha = osutils.sha_string(text)
1700
f = open('foo', 'rb')
1701
self.addCleanup(f.close)
1702
size, sha = osutils.size_sha_file(f)
1703
self.assertEqual(38, size)
1704
self.assertEqual(expected_sha, sha)
1707
class TestShaFileByName(tests.TestCaseInTempDir):
1709
def test_sha_empty(self):
1710
self.build_tree_contents([('foo', '')])
1711
expected_sha = osutils.sha_string('')
1712
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1714
def test_sha_mixed_endings(self):
1715
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1716
self.build_tree_contents([('foo', text)])
1717
expected_sha = osutils.sha_string(text)
1718
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1721
class TestResourceLoading(tests.TestCaseInTempDir):
1041
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1044
class TestLocalTimeOffset(TestCase):
1046
def test_local_time_offset(self):
1047
"""Test that local_time_offset() returns a sane value."""
1048
offset = osutils.local_time_offset()
1049
self.assertTrue(isinstance(offset, int))
1050
# Test that the offset is no more than a eighteen hours in
1052
# Time zone handling is system specific, so it is difficult to
1053
# do more specific tests, but a value outside of this range is
1055
eighteen_hours = 18 * 3600
1056
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1058
def test_local_time_offset_with_timestamp(self):
1059
"""Test that local_time_offset() works with a timestamp."""
1060
offset = osutils.local_time_offset(1000000000.1234567)
1061
self.assertTrue(isinstance(offset, int))
1062
eighteen_hours = 18 * 3600
1063
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1066
class TestShaFileByName(TestCaseInTempDir):
1068
def test_sha_empty(self):
1069
self.build_tree_contents([('foo', '')])
1070
expected_sha = osutils.sha_string('')
1071
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1073
def test_sha_mixed_endings(self):
1074
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1075
self.build_tree_contents([('foo', text)])
1076
expected_sha = osutils.sha_string(text)
1077
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1081
r'''# Copyright (C) 2005, 2006 Canonical Ltd
1083
# This program is free software; you can redistribute it and/or modify
1084
# it under the terms of the GNU General Public License as published by
1085
# the Free Software Foundation; either version 2 of the License, or
1086
# (at your option) any later version.
1088
# This program is distributed in the hope that it will be useful,
1089
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1090
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1091
# GNU General Public License for more details.
1093
# You should have received a copy of the GNU General Public License
1094
# along with this program; if not, write to the Free Software
1095
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1098
# NOTE: If update these, please also update the help for global-options in
1099
# bzrlib/help_topics/__init__.py
1102
"""Set of flags that enable different debug behaviour.
1104
These are set with eg ``-Dlock`` on the bzr command line.
1108
* auth - show authentication sections used
1109
* error - show stack traces for all top level exceptions
1110
* evil - capture call sites that do expensive or badly-scaling operations.
1111
* fetch - trace history copying between repositories
1112
* hashcache - log every time a working file is read to determine its hash
1113
* hooks - trace hook execution
1114
* hpss - trace smart protocol requests and responses
1115
* http - trace http connections, requests and responses
1116
* index - trace major index operations
1117
* knit - trace knit operations
1118
* lock - trace when lockdir locks are taken or released
1119
* merge - emit information for debugging merges
1120
* pack - emit information about pack operations
1126
class TestResourceLoading(TestCaseInTempDir):
1723
1128
def test_resource_string(self):
1724
1129
# test resource in bzrlib
1725
1130
text = osutils.resource_string('bzrlib', 'debug.py')
1726
self.assertContainsRe(text, "debug_flags = set()")
1131
self.assertEquals(_debug_text, text)
1727
1132
# test resource under bzrlib
1728
1133
text = osutils.resource_string('bzrlib.ui', 'text.py')
1729
1134
self.assertContainsRe(text, "class TextUIFactory")
1733
1138
# test unknown resource
1734
1139
self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1737
class TestReCompile(tests.TestCase):
1739
def _deprecated_re_compile_checked(self, *args, **kwargs):
1740
return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
1741
osutils.re_compile_checked, *args, **kwargs)
1743
def test_re_compile_checked(self):
1744
r = self._deprecated_re_compile_checked(r'A*', re.IGNORECASE)
1745
self.assertTrue(r.match('aaaa'))
1746
self.assertTrue(r.match('aAaA'))
1748
def test_re_compile_checked_error(self):
1749
# like https://bugs.launchpad.net/bzr/+bug/251352
1751
# Due to possible test isolation error, re.compile is not lazy at
1752
# this point. We re-install lazy compile.
1753
lazy_regex.install_lazy_compile()
1754
err = self.assertRaises(
1755
errors.BzrCommandError,
1756
self._deprecated_re_compile_checked, '*', re.IGNORECASE, 'test case')
1758
'Invalid regular expression in test case: '
1759
'"*" nothing to repeat',
1763
class TestDirReader(tests.TestCaseInTempDir):
1765
scenarios = dir_reader_scenarios()
1768
_dir_reader_class = None
1769
_native_to_unicode = None
1772
tests.TestCaseInTempDir.setUp(self)
1773
self.overrideAttr(osutils,
1774
'_selected_dir_reader', self._dir_reader_class())
1776
def _get_ascii_tree(self):
1784
expected_dirblocks = [
1786
[('0file', '0file', 'file'),
1787
('1dir', '1dir', 'directory'),
1788
('2file', '2file', 'file'),
1791
(('1dir', './1dir'),
1792
[('1dir/0file', '0file', 'file'),
1793
('1dir/1dir', '1dir', 'directory'),
1796
(('1dir/1dir', './1dir/1dir'),
1801
return tree, expected_dirblocks
1803
def test_walk_cur_dir(self):
1804
tree, expected_dirblocks = self._get_ascii_tree()
1805
self.build_tree(tree)
1806
result = list(osutils._walkdirs_utf8('.'))
1807
# Filter out stat and abspath
1808
self.assertEqual(expected_dirblocks,
1809
[(dirinfo, [line[0:3] for line in block])
1810
for dirinfo, block in result])
1812
def test_walk_sub_dir(self):
1813
tree, expected_dirblocks = self._get_ascii_tree()
1814
self.build_tree(tree)
1815
# you can search a subdir only, with a supplied prefix.
1816
result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1817
# Filter out stat and abspath
1818
self.assertEqual(expected_dirblocks[1:],
1819
[(dirinfo, [line[0:3] for line in block])
1820
for dirinfo, block in result])
1822
def _get_unicode_tree(self):
1823
name0u = u'0file-\xb6'
1824
name1u = u'1dir-\u062c\u0648'
1825
name2u = u'2file-\u0633'
1829
name1u + '/' + name0u,
1830
name1u + '/' + name1u + '/',
1833
name0 = name0u.encode('UTF-8')
1834
name1 = name1u.encode('UTF-8')
1835
name2 = name2u.encode('UTF-8')
1836
expected_dirblocks = [
1838
[(name0, name0, 'file', './' + name0u),
1839
(name1, name1, 'directory', './' + name1u),
1840
(name2, name2, 'file', './' + name2u),
1843
((name1, './' + name1u),
1844
[(name1 + '/' + name0, name0, 'file', './' + name1u
1846
(name1 + '/' + name1, name1, 'directory', './' + name1u
1850
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1855
return tree, expected_dirblocks
1857
def _filter_out(self, raw_dirblocks):
1858
"""Filter out a walkdirs_utf8 result.
1860
stat field is removed, all native paths are converted to unicode
1862
filtered_dirblocks = []
1863
for dirinfo, block in raw_dirblocks:
1864
dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1867
details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1868
filtered_dirblocks.append((dirinfo, details))
1869
return filtered_dirblocks
1871
def test_walk_unicode_tree(self):
1872
self.requireFeature(features.UnicodeFilenameFeature)
1873
tree, expected_dirblocks = self._get_unicode_tree()
1874
self.build_tree(tree)
1875
result = list(osutils._walkdirs_utf8('.'))
1876
self.assertEqual(expected_dirblocks, self._filter_out(result))
1878
def test_symlink(self):
1879
self.requireFeature(features.SymlinkFeature)
1880
self.requireFeature(features.UnicodeFilenameFeature)
1881
target = u'target\N{Euro Sign}'
1882
link_name = u'l\N{Euro Sign}nk'
1883
os.symlink(target, link_name)
1884
target_utf8 = target.encode('UTF-8')
1885
link_name_utf8 = link_name.encode('UTF-8')
1886
expected_dirblocks = [
1888
[(link_name_utf8, link_name_utf8,
1889
'symlink', './' + link_name),],
1891
result = list(osutils._walkdirs_utf8('.'))
1892
self.assertEqual(expected_dirblocks, self._filter_out(result))
1895
class TestReadLink(tests.TestCaseInTempDir):
1896
"""Exposes os.readlink() problems and the osutils solution.
1898
The only guarantee offered by os.readlink(), starting with 2.6, is that a
1899
unicode string will be returned if a unicode string is passed.
1901
But prior python versions failed to properly encode the passed unicode
1904
_test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]
1907
super(tests.TestCaseInTempDir, self).setUp()
1908
self.link = u'l\N{Euro Sign}ink'
1909
self.target = u'targe\N{Euro Sign}t'
1910
os.symlink(self.target, self.link)
1912
def test_os_readlink_link_encoding(self):
1913
self.assertEquals(self.target, os.readlink(self.link))
1915
def test_os_readlink_link_decoding(self):
1916
self.assertEquals(self.target.encode(osutils._fs_enc),
1917
os.readlink(self.link.encode(osutils._fs_enc)))
1920
class TestConcurrency(tests.TestCase):
1923
super(TestConcurrency, self).setUp()
1924
self.overrideAttr(osutils, '_cached_local_concurrency')
1926
def test_local_concurrency(self):
1927
concurrency = osutils.local_concurrency()
1928
self.assertIsInstance(concurrency, int)
1930
def test_local_concurrency_environment_variable(self):
1931
self.overrideEnv('BZR_CONCURRENCY', '2')
1932
self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1933
self.overrideEnv('BZR_CONCURRENCY', '3')
1934
self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1935
self.overrideEnv('BZR_CONCURRENCY', 'foo')
1936
self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1938
def test_option_concurrency(self):
1939
self.overrideEnv('BZR_CONCURRENCY', '1')
1940
self.run_bzr('rocks --concurrency 42')
1941
# Command line overrides environment variable
1942
self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1943
self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1946
class TestFailedToLoadExtension(tests.TestCase):
1948
def _try_loading(self):
1950
import bzrlib._fictional_extension_py
1951
except ImportError, e:
1952
osutils.failed_to_load_extension(e)
1956
super(TestFailedToLoadExtension, self).setUp()
1957
self.overrideAttr(osutils, '_extension_load_failures', [])
1959
def test_failure_to_load(self):
1961
self.assertLength(1, osutils._extension_load_failures)
1962
self.assertEquals(osutils._extension_load_failures[0],
1963
"No module named _fictional_extension_py")
1965
def test_report_extension_load_failures_no_warning(self):
1966
self.assertTrue(self._try_loading())
1967
warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
1968
# it used to give a Python warning; it no longer does
1969
self.assertLength(0, warnings)
1971
def test_report_extension_load_failures_message(self):
1973
trace.push_log_file(log)
1974
self.assertTrue(self._try_loading())
1975
osutils.report_extension_load_failures()
1976
self.assertContainsRe(
1978
r"bzr: warning: some compiled extensions could not be loaded; "
1979
"see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1983
class TestTerminalWidth(tests.TestCase):
1986
tests.TestCase.setUp(self)
1987
self._orig_terminal_size_state = osutils._terminal_size_state
1988
self._orig_first_terminal_size = osutils._first_terminal_size
1989
self.addCleanup(self.restore_osutils_globals)
1990
osutils._terminal_size_state = 'no_data'
1991
osutils._first_terminal_size = None
1993
def restore_osutils_globals(self):
1994
osutils._terminal_size_state = self._orig_terminal_size_state
1995
osutils._first_terminal_size = self._orig_first_terminal_size
1997
def replace_stdout(self, new):
1998
self.overrideAttr(sys, 'stdout', new)
2000
def replace__terminal_size(self, new):
2001
self.overrideAttr(osutils, '_terminal_size', new)
2003
def set_fake_tty(self):
2005
class I_am_a_tty(object):
2009
self.replace_stdout(I_am_a_tty())
2011
def test_default_values(self):
2012
self.assertEqual(80, osutils.default_terminal_width)
2014
def test_defaults_to_BZR_COLUMNS(self):
2015
# BZR_COLUMNS is set by the test framework
2016
self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
2017
self.overrideEnv('BZR_COLUMNS', '12')
2018
self.assertEqual(12, osutils.terminal_width())
2020
def test_BZR_COLUMNS_0_no_limit(self):
2021
self.overrideEnv('BZR_COLUMNS', '0')
2022
self.assertEqual(None, osutils.terminal_width())
2024
def test_falls_back_to_COLUMNS(self):
2025
self.overrideEnv('BZR_COLUMNS', None)
2026
self.assertNotEqual('42', os.environ['COLUMNS'])
2028
self.overrideEnv('COLUMNS', '42')
2029
self.assertEqual(42, osutils.terminal_width())
2031
def test_tty_default_without_columns(self):
2032
self.overrideEnv('BZR_COLUMNS', None)
2033
self.overrideEnv('COLUMNS', None)
2035
def terminal_size(w, h):
2039
# We need to override the osutils definition as it depends on the
2040
# running environment that we can't control (PQM running without a
2041
# controlling terminal is one example).
2042
self.replace__terminal_size(terminal_size)
2043
self.assertEqual(42, osutils.terminal_width())
2045
def test_non_tty_default_without_columns(self):
2046
self.overrideEnv('BZR_COLUMNS', None)
2047
self.overrideEnv('COLUMNS', None)
2048
self.replace_stdout(None)
2049
self.assertEqual(None, osutils.terminal_width())
2051
def test_no_TIOCGWINSZ(self):
2052
self.requireFeature(term_ios_feature)
2053
termios = term_ios_feature.module
2054
# bug 63539 is about a termios without TIOCGWINSZ attribute
2056
orig = termios.TIOCGWINSZ
2057
except AttributeError:
2058
# We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
2061
self.overrideAttr(termios, 'TIOCGWINSZ')
2062
del termios.TIOCGWINSZ
2063
self.overrideEnv('BZR_COLUMNS', None)
2064
self.overrideEnv('COLUMNS', None)
2065
# Whatever the result is, if we don't raise an exception, it's ok.
2066
osutils.terminal_width()
2069
class TestCreationOps(tests.TestCaseInTempDir):
2070
_test_needs_features = [features.chown_feature]
2073
tests.TestCaseInTempDir.setUp(self)
2074
self.overrideAttr(os, 'chown', self._dummy_chown)
2076
# params set by call to _dummy_chown
2077
self.path = self.uid = self.gid = None
2079
def _dummy_chown(self, path, uid, gid):
2080
self.path, self.uid, self.gid = path, uid, gid
2082
def test_copy_ownership_from_path(self):
2083
"""copy_ownership_from_path test with specified src."""
2085
f = open('test_file', 'wt')
2086
osutils.copy_ownership_from_path('test_file', ownsrc)
2089
self.assertEquals(self.path, 'test_file')
2090
self.assertEquals(self.uid, s.st_uid)
2091
self.assertEquals(self.gid, s.st_gid)
2093
def test_copy_ownership_nonesrc(self):
2094
"""copy_ownership_from_path test with src=None."""
2095
f = open('test_file', 'wt')
2096
# should use parent dir for permissions
2097
osutils.copy_ownership_from_path('test_file')
2100
self.assertEquals(self.path, 'test_file')
2101
self.assertEquals(self.uid, s.st_uid)
2102
self.assertEquals(self.gid, s.st_gid)
2105
class TestGetuserUnicode(tests.TestCase):
2107
def test_ascii_user(self):
2108
self.overrideEnv('LOGNAME', 'jrandom')
2109
self.assertEqual(u'jrandom', osutils.getuser_unicode())
2111
def test_unicode_user(self):
2112
ue = osutils.get_user_encoding()
2113
uni_val, env_val = tests.probe_unicode_in_user_encoding()
2115
raise tests.TestSkipped(
2116
'Cannot find a unicode character that works in encoding %s'
2117
% (osutils.get_user_encoding(),))
2118
uni_username = u'jrandom' + uni_val
2119
encoded_username = uni_username.encode(ue)
2120
self.overrideEnv('LOGNAME', encoded_username)
2121
self.assertEqual(uni_username, osutils.getuser_unicode())
2122
self.overrideEnv('LOGNAME', u'jrandom\xb6'.encode(ue))
2123
self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())
2125
def test_no_username_bug_660174(self):
2126
self.requireFeature(features.win32_feature)
2127
for name in ('LOGNAME', 'USER', 'LNAME', 'USERNAME'):
2128
self.overrideEnv(name, None)
2129
self.assertEqual(u'UNKNOWN', osutils.getuser_unicode())
2132
class TestBackupNames(tests.TestCase):
2135
super(TestBackupNames, self).setUp()
2138
def backup_exists(self, name):
2139
return name in self.backups
2141
def available_backup_name(self, name):
2142
backup_name = osutils.available_backup_name(name, self.backup_exists)
2143
self.backups.append(backup_name)
2146
def assertBackupName(self, expected, name):
2147
self.assertEqual(expected, self.available_backup_name(name))
2149
def test_empty(self):
2150
self.assertBackupName('file.~1~', 'file')
2152
def test_existing(self):
2153
self.available_backup_name('file')
2154
self.available_backup_name('file')
2155
self.assertBackupName('file.~3~', 'file')
2156
# Empty slots are found, this is not a strict requirement and may be
2157
# revisited if we test against all implementations.
2158
self.backups.remove('file.~2~')
2159
self.assertBackupName('file.~2~', 'file')
2162
class TestFindExecutableInPath(tests.TestCase):
2164
def test_windows(self):
2165
if sys.platform != 'win32':
2166
raise tests.TestSkipped('test requires win32')
2167
self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
2169
osutils.find_executable_on_path('explorer.exe') is not None)
2171
osutils.find_executable_on_path('EXPLORER.EXE') is not None)
2173
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2174
self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2176
def test_other(self):
2177
if sys.platform == 'win32':
2178
raise tests.TestSkipped('test requires non-win32')
2179
self.assertTrue(osutils.find_executable_on_path('sh') is not None)
2181
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
added
removed
bzrlib/tests/test_osutils.py
