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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
"""Tests for the osutils wrapper."""
19
from cStringIO import StringIO
26
28
from bzrlib import (
31
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
32
37
from bzrlib.tests import (
40
class TestOSUtils(TestCaseInTempDir):
42
from bzrlib.tests.scenarios import load_tests_apply_scenarios
45
class _UTF8DirReaderFeature(features.Feature):
49
from bzrlib import _readdir_pyx
50
self.reader = _readdir_pyx.UTF8DirReader
55
def feature_name(self):
56
return 'bzrlib._readdir_pyx'
58
UTF8DirReaderFeature = features.ModuleAvailableFeature('bzrlib._readdir_pyx')
60
term_ios_feature = features.ModuleAvailableFeature('termios')
63
def _already_unicode(s):
67
def _utf8_to_unicode(s):
68
return s.decode('UTF-8')
71
def dir_reader_scenarios():
72
# For each dir reader we define:
74
# - native_to_unicode: a function converting the native_abspath as returned
75
# by DirReader.read_dir to its unicode representation
77
# UnicodeDirReader is the fallback, it should be tested on all platforms.
78
scenarios = [('unicode',
79
dict(_dir_reader_class=osutils.UnicodeDirReader,
80
_native_to_unicode=_already_unicode))]
81
# Some DirReaders are platform specific and even there they may not be
83
if UTF8DirReaderFeature.available():
84
from bzrlib import _readdir_pyx
85
scenarios.append(('utf8',
86
dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
87
_native_to_unicode=_utf8_to_unicode)))
89
if test__walkdirs_win32.win32_readdir_feature.available():
91
from bzrlib import _walkdirs_win32
94
dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
95
_native_to_unicode=_already_unicode)))
101
load_tests = load_tests_apply_scenarios
104
class TestContainsWhitespace(tests.TestCase):
42
106
def test_contains_whitespace(self):
43
self.failUnless(osutils.contains_whitespace(u' '))
44
self.failUnless(osutils.contains_whitespace(u'hello there'))
45
self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
46
self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
47
self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
48
self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
107
self.assertTrue(osutils.contains_whitespace(u' '))
108
self.assertTrue(osutils.contains_whitespace(u'hello there'))
109
self.assertTrue(osutils.contains_whitespace(u'hellothere\n'))
110
self.assertTrue(osutils.contains_whitespace(u'hello\nthere'))
111
self.assertTrue(osutils.contains_whitespace(u'hello\rthere'))
112
self.assertTrue(osutils.contains_whitespace(u'hello\tthere'))
50
114
# \xa0 is "Non-breaking-space" which on some python locales thinks it
51
115
# is whitespace, but we do not.
52
self.failIf(osutils.contains_whitespace(u''))
53
self.failIf(osutils.contains_whitespace(u'hellothere'))
54
self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
116
self.assertFalse(osutils.contains_whitespace(u''))
117
self.assertFalse(osutils.contains_whitespace(u'hellothere'))
118
self.assertFalse(osutils.contains_whitespace(u'hello\xa0there'))
121
class TestRename(tests.TestCaseInTempDir):
123
def create_file(self, filename, content):
124
f = open(filename, 'wb')
130
def _fancy_rename(self, a, b):
131
osutils.fancy_rename(a, b, rename_func=os.rename,
132
unlink_func=os.unlink)
56
134
def test_fancy_rename(self):
57
135
# This should work everywhere
59
osutils.fancy_rename(a, b,
60
rename_func=os.rename,
61
unlink_func=os.unlink)
63
open('a', 'wb').write('something in a\n')
65
self.failIfExists('a')
66
self.failUnlessExists('b')
136
self.create_file('a', 'something in a\n')
137
self._fancy_rename('a', 'b')
138
self.assertPathDoesNotExist('a')
139
self.assertPathExists('b')
67
140
self.check_file_contents('b', 'something in a\n')
69
open('a', 'wb').write('new something in a\n')
142
self.create_file('a', 'new something in a\n')
143
self._fancy_rename('b', 'a')
72
145
self.check_file_contents('a', 'something in a\n')
147
def test_fancy_rename_fails_source_missing(self):
148
# An exception should be raised, and the target should be left in place
149
self.create_file('target', 'data in target\n')
150
self.assertRaises((IOError, OSError), self._fancy_rename,
151
'missingsource', 'target')
152
self.assertPathExists('target')
153
self.check_file_contents('target', 'data in target\n')
155
def test_fancy_rename_fails_if_source_and_target_missing(self):
156
self.assertRaises((IOError, OSError), self._fancy_rename,
157
'missingsource', 'missingtarget')
74
159
def test_rename(self):
75
160
# Rename should be semi-atomic on all platforms
76
open('a', 'wb').write('something in a\n')
161
self.create_file('a', 'something in a\n')
77
162
osutils.rename('a', 'b')
78
self.failIfExists('a')
79
self.failUnlessExists('b')
163
self.assertPathDoesNotExist('a')
164
self.assertPathExists('b')
80
165
self.check_file_contents('b', 'something in a\n')
82
open('a', 'wb').write('new something in a\n')
167
self.create_file('a', 'new something in a\n')
83
168
osutils.rename('b', 'a')
85
170
self.check_file_contents('a', 'something in a\n')
87
172
# TODO: test fancy_rename using a MemoryTransport
174
def test_rename_change_case(self):
175
# on Windows we should be able to change filename case by rename
176
self.build_tree(['a', 'b/'])
177
osutils.rename('a', 'A')
178
osutils.rename('b', 'B')
179
# we can't use failUnlessExists on case-insensitive filesystem
180
# so try to check shape of the tree
181
shape = sorted(os.listdir('.'))
182
self.assertEquals(['A', 'B'], shape)
184
def test_rename_exception(self):
186
osutils.rename('nonexistent_path', 'different_nonexistent_path')
188
self.assertEqual(e.old_filename, 'nonexistent_path')
189
self.assertEqual(e.new_filename, 'different_nonexistent_path')
190
self.assertTrue('nonexistent_path' in e.strerror)
191
self.assertTrue('different_nonexistent_path' in e.strerror)
194
class TestRandChars(tests.TestCase):
89
196
def test_01_rand_chars_empty(self):
90
197
result = osutils.rand_chars(0)
91
198
self.assertEqual(result, '')
240
465
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
241
466
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
244
class TestSafeUnicode(TestCase):
468
def test_changing_access(self):
469
f = file('file', 'w')
473
# Make a file readonly
474
osutils.make_readonly('file')
475
mode = os.lstat('file').st_mode
476
self.assertEqual(mode, mode & 0777555)
478
# Make a file writable
479
osutils.make_writable('file')
480
mode = os.lstat('file').st_mode
481
self.assertEqual(mode, mode | 0200)
483
if osutils.has_symlinks():
484
# should not error when handed a symlink
485
os.symlink('nonexistent', 'dangling')
486
osutils.make_readonly('dangling')
487
osutils.make_writable('dangling')
489
def test_host_os_dereferences_symlinks(self):
490
osutils.host_os_dereferences_symlinks()
493
class TestCanonicalRelPath(tests.TestCaseInTempDir):
495
_test_needs_features = [features.CaseInsCasePresFilenameFeature]
497
def test_canonical_relpath_simple(self):
498
f = file('MixedCaseName', 'w')
500
actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
501
self.assertEqual('work/MixedCaseName', actual)
503
def test_canonical_relpath_missing_tail(self):
504
os.mkdir('MixedCaseParent')
505
actual = osutils.canonical_relpath(self.test_base_dir,
506
'mixedcaseparent/nochild')
507
self.assertEqual('work/MixedCaseParent/nochild', actual)
510
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
512
def assertRelpath(self, expected, base, path):
513
actual = osutils._cicp_canonical_relpath(base, path)
514
self.assertEqual(expected, actual)
516
def test_simple(self):
517
self.build_tree(['MixedCaseName'])
518
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
519
self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
521
def test_subdir_missing_tail(self):
522
self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
523
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
524
self.assertRelpath('MixedCaseParent/a_child', base,
525
'MixedCaseParent/a_child')
526
self.assertRelpath('MixedCaseParent/a_child', base,
527
'MixedCaseParent/A_Child')
528
self.assertRelpath('MixedCaseParent/not_child', base,
529
'MixedCaseParent/not_child')
531
def test_at_root_slash(self):
532
# We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
534
if osutils.MIN_ABS_PATHLENGTH > 1:
535
raise tests.TestSkipped('relpath requires %d chars'
536
% osutils.MIN_ABS_PATHLENGTH)
537
self.assertRelpath('foo', '/', '/foo')
539
def test_at_root_drive(self):
540
if sys.platform != 'win32':
541
raise tests.TestNotApplicable('we can only test drive-letter relative'
542
' paths on Windows where we have drive'
545
# The specific issue is that when at the root of a drive, 'abspath'
546
# returns "C:/" or just "/". However, the code assumes that abspath
547
# always returns something like "C:/foo" or "/foo" (no trailing slash).
548
self.assertRelpath('foo', 'C:/', 'C:/foo')
549
self.assertRelpath('foo', 'X:/', 'X:/foo')
550
self.assertRelpath('foo', 'X:/', 'X://foo')
553
class TestPumpFile(tests.TestCase):
554
"""Test pumpfile method."""
557
tests.TestCase.setUp(self)
558
# create a test datablock
559
self.block_size = 512
560
pattern = '0123456789ABCDEF'
561
self.test_data = pattern * (3 * self.block_size / len(pattern))
562
self.test_data_len = len(self.test_data)
564
def test_bracket_block_size(self):
565
"""Read data in blocks with the requested read size bracketing the
567
# make sure test data is larger than max read size
568
self.assertTrue(self.test_data_len > self.block_size)
570
from_file = file_utils.FakeReadFile(self.test_data)
573
# read (max / 2) bytes and verify read size wasn't affected
574
num_bytes_to_read = self.block_size / 2
575
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
576
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
577
self.assertEqual(from_file.get_read_count(), 1)
579
# read (max) bytes and verify read size wasn't affected
580
num_bytes_to_read = self.block_size
581
from_file.reset_read_count()
582
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
583
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
584
self.assertEqual(from_file.get_read_count(), 1)
586
# read (max + 1) bytes and verify read size was limited
587
num_bytes_to_read = self.block_size + 1
588
from_file.reset_read_count()
589
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
590
self.assertEqual(from_file.get_max_read_size(), self.block_size)
591
self.assertEqual(from_file.get_read_count(), 2)
593
# finish reading the rest of the data
594
num_bytes_to_read = self.test_data_len - to_file.tell()
595
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
597
# report error if the data wasn't equal (we only report the size due
598
# to the length of the data)
599
response_data = to_file.getvalue()
600
if response_data != self.test_data:
601
message = "Data not equal. Expected %d bytes, received %d."
602
self.fail(message % (len(response_data), self.test_data_len))
604
def test_specified_size(self):
605
"""Request a transfer larger than the maximum block size and verify
606
that the maximum read doesn't exceed the block_size."""
607
# make sure test data is larger than max read size
608
self.assertTrue(self.test_data_len > self.block_size)
610
# retrieve data in blocks
611
from_file = file_utils.FakeReadFile(self.test_data)
613
osutils.pumpfile(from_file, to_file, self.test_data_len,
616
# verify read size was equal to the maximum read size
617
self.assertTrue(from_file.get_max_read_size() > 0)
618
self.assertEqual(from_file.get_max_read_size(), self.block_size)
619
self.assertEqual(from_file.get_read_count(), 3)
621
# report error if the data wasn't equal (we only report the size due
622
# to the length of the data)
623
response_data = to_file.getvalue()
624
if response_data != self.test_data:
625
message = "Data not equal. Expected %d bytes, received %d."
626
self.fail(message % (len(response_data), self.test_data_len))
628
def test_to_eof(self):
629
"""Read to end-of-file and verify that the reads are not larger than
630
the maximum read size."""
631
# make sure test data is larger than max read size
632
self.assertTrue(self.test_data_len > self.block_size)
634
# retrieve data to EOF
635
from_file = file_utils.FakeReadFile(self.test_data)
637
osutils.pumpfile(from_file, to_file, -1, self.block_size)
639
# verify read size was equal to the maximum read size
640
self.assertEqual(from_file.get_max_read_size(), self.block_size)
641
self.assertEqual(from_file.get_read_count(), 4)
643
# report error if the data wasn't equal (we only report the size due
644
# to the length of the data)
645
response_data = to_file.getvalue()
646
if response_data != self.test_data:
647
message = "Data not equal. Expected %d bytes, received %d."
648
self.fail(message % (len(response_data), self.test_data_len))
650
def test_defaults(self):
651
"""Verifies that the default arguments will read to EOF -- this
652
test verifies that any existing usages of pumpfile will not be broken
653
with this new version."""
654
# retrieve data using default (old) pumpfile method
655
from_file = file_utils.FakeReadFile(self.test_data)
657
osutils.pumpfile(from_file, to_file)
659
# report error if the data wasn't equal (we only report the size due
660
# to the length of the data)
661
response_data = to_file.getvalue()
662
if response_data != self.test_data:
663
message = "Data not equal. Expected %d bytes, received %d."
664
self.fail(message % (len(response_data), self.test_data_len))
666
def test_report_activity(self):
668
def log_activity(length, direction):
669
activity.append((length, direction))
670
from_file = StringIO(self.test_data)
672
osutils.pumpfile(from_file, to_file, buff_size=500,
673
report_activity=log_activity, direction='read')
674
self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
675
(36, 'read')], activity)
677
from_file = StringIO(self.test_data)
680
osutils.pumpfile(from_file, to_file, buff_size=500,
681
report_activity=log_activity, direction='write')
682
self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
683
(36, 'write')], activity)
685
# And with a limited amount of data
686
from_file = StringIO(self.test_data)
689
osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
690
report_activity=log_activity, direction='read')
691
self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
695
class TestPumpStringFile(tests.TestCase):
697
def test_empty(self):
699
osutils.pump_string_file("", output)
700
self.assertEqual("", output.getvalue())
702
def test_more_than_segment_size(self):
704
osutils.pump_string_file("123456789", output, 2)
705
self.assertEqual("123456789", output.getvalue())
707
def test_segment_size(self):
709
osutils.pump_string_file("12", output, 2)
710
self.assertEqual("12", output.getvalue())
712
def test_segment_size_multiple(self):
714
osutils.pump_string_file("1234", output, 2)
715
self.assertEqual("1234", output.getvalue())
718
class TestRelpath(tests.TestCase):
720
def test_simple_relpath(self):
721
cwd = osutils.getcwd()
722
subdir = cwd + '/subdir'
723
self.assertEqual('subdir', osutils.relpath(cwd, subdir))
725
def test_deep_relpath(self):
726
cwd = osutils.getcwd()
727
subdir = cwd + '/sub/subsubdir'
728
self.assertEqual('sub/subsubdir', osutils.relpath(cwd, subdir))
730
def test_not_relative(self):
731
self.assertRaises(errors.PathNotChild,
732
osutils.relpath, 'C:/path', 'H:/path')
733
self.assertRaises(errors.PathNotChild,
734
osutils.relpath, 'C:/', 'H:/path')
737
class TestSafeUnicode(tests.TestCase):
246
739
def test_from_ascii_string(self):
247
740
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
720
1359
result.append((dirdetail, new_dirblock))
721
1360
self.assertEqual(expected_dirblocks, result)
723
def test_unicode__walkdirs_unicode_to_utf8(self):
724
"""walkdirs_unicode_to_utf8 should be a safe fallback everywhere
1362
def test__walkdirs_utf8_with_unicode_fs(self):
1363
"""UnicodeDirReader should be a safe fallback everywhere
726
1365
The abspath portion should be in unicode
728
name0u = u'0file-\xb6'
729
name1u = u'1dir-\u062c\u0648'
730
name2u = u'2file-\u0633'
734
name1u + '/' + name0u,
735
name1u + '/' + name1u + '/',
1367
self.requireFeature(features.UnicodeFilenameFeature)
1368
# Use the unicode reader. TODO: split into driver-and-driven unit
1370
self._save_platform_info()
1371
osutils._selected_dir_reader = osutils.UnicodeDirReader()
1372
name0u = u'0file-\xb6'
1373
name1u = u'1dir-\u062c\u0648'
1374
name2u = u'2file-\u0633'
1378
name1u + '/' + name0u,
1379
name1u + '/' + name1u + '/',
1382
self.build_tree(tree)
1383
name0 = name0u.encode('utf8')
1384
name1 = name1u.encode('utf8')
1385
name2 = name2u.encode('utf8')
1387
# All of the abspaths should be in unicode, all of the relative paths
1389
expected_dirblocks = [
1391
[(name0, name0, 'file', './' + name0u),
1392
(name1, name1, 'directory', './' + name1u),
1393
(name2, name2, 'file', './' + name2u),
1396
((name1, './' + name1u),
1397
[(name1 + '/' + name0, name0, 'file', './' + name1u
1399
(name1 + '/' + name1, name1, 'directory', './' + name1u
1403
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1408
result = list(osutils._walkdirs_utf8('.'))
1409
self._filter_out_stat(result)
1410
self.assertEqual(expected_dirblocks, result)
1412
def test__walkdirs_utf8_win32readdir(self):
1413
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1414
self.requireFeature(features.UnicodeFilenameFeature)
1415
from bzrlib._walkdirs_win32 import Win32ReadDir
1416
self._save_platform_info()
1417
osutils._selected_dir_reader = Win32ReadDir()
1418
name0u = u'0file-\xb6'
1419
name1u = u'1dir-\u062c\u0648'
1420
name2u = u'2file-\u0633'
1424
name1u + '/' + name0u,
1425
name1u + '/' + name1u + '/',
1428
self.build_tree(tree)
1429
name0 = name0u.encode('utf8')
1430
name1 = name1u.encode('utf8')
1431
name2 = name2u.encode('utf8')
1433
# All of the abspaths should be in unicode, all of the relative paths
1435
expected_dirblocks = [
1437
[(name0, name0, 'file', './' + name0u),
1438
(name1, name1, 'directory', './' + name1u),
1439
(name2, name2, 'file', './' + name2u),
1442
((name1, './' + name1u),
1443
[(name1 + '/' + name0, name0, 'file', './' + name1u
1445
(name1 + '/' + name1, name1, 'directory', './' + name1u
1449
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1454
result = list(osutils._walkdirs_utf8(u'.'))
1455
self._filter_out_stat(result)
1456
self.assertEqual(expected_dirblocks, result)
1458
def assertStatIsCorrect(self, path, win32stat):
1459
os_stat = os.stat(path)
1460
self.assertEqual(os_stat.st_size, win32stat.st_size)
1461
self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
1462
self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
1463
self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
1464
self.assertEqual(os_stat.st_dev, win32stat.st_dev)
1465
self.assertEqual(os_stat.st_ino, win32stat.st_ino)
1466
self.assertEqual(os_stat.st_mode, win32stat.st_mode)
1468
def test__walkdirs_utf_win32_find_file_stat_file(self):
1469
"""make sure our Stat values are valid"""
1470
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1471
self.requireFeature(features.UnicodeFilenameFeature)
1472
from bzrlib._walkdirs_win32 import Win32ReadDir
1473
name0u = u'0file-\xb6'
1474
name0 = name0u.encode('utf8')
1475
self.build_tree([name0u])
1476
# I hate to sleep() here, but I'm trying to make the ctime different
1479
f = open(name0u, 'ab')
739
self.build_tree(tree)
741
raise TestSkipped('Could not represent Unicode chars'
742
' in current encoding.')
1481
f.write('just a small update')
1485
result = Win32ReadDir().read_dir('', u'.')
1487
self.assertEqual((name0, name0, 'file'), entry[:3])
1488
self.assertEqual(u'./' + name0u, entry[4])
1489
self.assertStatIsCorrect(entry[4], entry[3])
1490
self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
1492
def test__walkdirs_utf_win32_find_file_stat_directory(self):
1493
"""make sure our Stat values are valid"""
1494
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1495
self.requireFeature(features.UnicodeFilenameFeature)
1496
from bzrlib._walkdirs_win32 import Win32ReadDir
1497
name0u = u'0dir-\u062c\u0648'
743
1498
name0 = name0u.encode('utf8')
744
name1 = name1u.encode('utf8')
745
name2 = name2u.encode('utf8')
1499
self.build_tree([name0u + '/'])
747
# All of the abspaths should be in unicode, all of the relative paths
749
expected_dirblocks = [
751
[(name0, name0, 'file', './' + name0u),
752
(name1, name1, 'directory', './' + name1u),
753
(name2, name2, 'file', './' + name2u),
756
((name1, './' + name1u),
757
[(name1 + '/' + name0, name0, 'file', './' + name1u
759
(name1 + '/' + name1, name1, 'directory', './' + name1u
763
((name1 + '/' + name1, './' + name1u + '/' + name1u),
768
result = list(osutils._walkdirs_unicode_to_utf8('.'))
769
self._filter_out_stat(result)
770
self.assertEqual(expected_dirblocks, result)
1501
result = Win32ReadDir().read_dir('', u'.')
1503
self.assertEqual((name0, name0, 'directory'), entry[:3])
1504
self.assertEqual(u'./' + name0u, entry[4])
1505
self.assertStatIsCorrect(entry[4], entry[3])
772
1507
def assertPathCompare(self, path_less, path_greater):
773
1508
"""check that path_less and path_greater compare correctly."""
961
1681
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
962
1682
self.assertEqual('foo', old)
963
1683
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
964
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
967
class TestLocalTimeOffset(TestCase):
969
def test_local_time_offset(self):
970
"""Test that local_time_offset() returns a sane value."""
971
offset = osutils.local_time_offset()
972
self.assertTrue(isinstance(offset, int))
973
# Test that the offset is no more than a eighteen hours in
975
# Time zone handling is system specific, so it is difficult to
976
# do more specific tests, but a value outside of this range is
978
eighteen_hours = 18 * 3600
979
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
981
def test_local_time_offset_with_timestamp(self):
982
"""Test that local_time_offset() works with a timestamp."""
983
offset = osutils.local_time_offset(1000000000.1234567)
984
self.assertTrue(isinstance(offset, int))
985
eighteen_hours = 18 * 3600
986
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1684
self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
1687
class TestSizeShaFile(tests.TestCaseInTempDir):
1689
def test_sha_empty(self):
1690
self.build_tree_contents([('foo', '')])
1691
expected_sha = osutils.sha_string('')
1693
self.addCleanup(f.close)
1694
size, sha = osutils.size_sha_file(f)
1695
self.assertEqual(0, size)
1696
self.assertEqual(expected_sha, sha)
1698
def test_sha_mixed_endings(self):
1699
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1700
self.build_tree_contents([('foo', text)])
1701
expected_sha = osutils.sha_string(text)
1702
f = open('foo', 'rb')
1703
self.addCleanup(f.close)
1704
size, sha = osutils.size_sha_file(f)
1705
self.assertEqual(38, size)
1706
self.assertEqual(expected_sha, sha)
1709
class TestShaFileByName(tests.TestCaseInTempDir):
1711
def test_sha_empty(self):
1712
self.build_tree_contents([('foo', '')])
1713
expected_sha = osutils.sha_string('')
1714
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1716
def test_sha_mixed_endings(self):
1717
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1718
self.build_tree_contents([('foo', text)])
1719
expected_sha = osutils.sha_string(text)
1720
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1723
class TestResourceLoading(tests.TestCaseInTempDir):
1725
def test_resource_string(self):
1726
# test resource in bzrlib
1727
text = osutils.resource_string('bzrlib', 'debug.py')
1728
self.assertContainsRe(text, "debug_flags = set()")
1729
# test resource under bzrlib
1730
text = osutils.resource_string('bzrlib.ui', 'text.py')
1731
self.assertContainsRe(text, "class TextUIFactory")
1732
# test unsupported package
1733
self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1735
# test unknown resource
1736
self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1739
class TestReCompile(tests.TestCase):
1741
def _deprecated_re_compile_checked(self, *args, **kwargs):
1742
return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
1743
osutils.re_compile_checked, *args, **kwargs)
1745
def test_re_compile_checked(self):
1746
r = self._deprecated_re_compile_checked(r'A*', re.IGNORECASE)
1747
self.assertTrue(r.match('aaaa'))
1748
self.assertTrue(r.match('aAaA'))
1750
def test_re_compile_checked_error(self):
1751
# like https://bugs.launchpad.net/bzr/+bug/251352
1753
# Due to possible test isolation error, re.compile is not lazy at
1754
# this point. We re-install lazy compile.
1755
lazy_regex.install_lazy_compile()
1756
err = self.assertRaises(
1757
errors.BzrCommandError,
1758
self._deprecated_re_compile_checked, '*', re.IGNORECASE, 'test case')
1760
'Invalid regular expression in test case: '
1761
'"*" nothing to repeat',
1765
class TestDirReader(tests.TestCaseInTempDir):
1767
scenarios = dir_reader_scenarios()
1770
_dir_reader_class = None
1771
_native_to_unicode = None
1774
tests.TestCaseInTempDir.setUp(self)
1775
self.overrideAttr(osutils,
1776
'_selected_dir_reader', self._dir_reader_class())
1778
def _get_ascii_tree(self):
1786
expected_dirblocks = [
1788
[('0file', '0file', 'file'),
1789
('1dir', '1dir', 'directory'),
1790
('2file', '2file', 'file'),
1793
(('1dir', './1dir'),
1794
[('1dir/0file', '0file', 'file'),
1795
('1dir/1dir', '1dir', 'directory'),
1798
(('1dir/1dir', './1dir/1dir'),
1803
return tree, expected_dirblocks
1805
def test_walk_cur_dir(self):
1806
tree, expected_dirblocks = self._get_ascii_tree()
1807
self.build_tree(tree)
1808
result = list(osutils._walkdirs_utf8('.'))
1809
# Filter out stat and abspath
1810
self.assertEqual(expected_dirblocks,
1811
[(dirinfo, [line[0:3] for line in block])
1812
for dirinfo, block in result])
1814
def test_walk_sub_dir(self):
1815
tree, expected_dirblocks = self._get_ascii_tree()
1816
self.build_tree(tree)
1817
# you can search a subdir only, with a supplied prefix.
1818
result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1819
# Filter out stat and abspath
1820
self.assertEqual(expected_dirblocks[1:],
1821
[(dirinfo, [line[0:3] for line in block])
1822
for dirinfo, block in result])
1824
def _get_unicode_tree(self):
1825
name0u = u'0file-\xb6'
1826
name1u = u'1dir-\u062c\u0648'
1827
name2u = u'2file-\u0633'
1831
name1u + '/' + name0u,
1832
name1u + '/' + name1u + '/',
1835
name0 = name0u.encode('UTF-8')
1836
name1 = name1u.encode('UTF-8')
1837
name2 = name2u.encode('UTF-8')
1838
expected_dirblocks = [
1840
[(name0, name0, 'file', './' + name0u),
1841
(name1, name1, 'directory', './' + name1u),
1842
(name2, name2, 'file', './' + name2u),
1845
((name1, './' + name1u),
1846
[(name1 + '/' + name0, name0, 'file', './' + name1u
1848
(name1 + '/' + name1, name1, 'directory', './' + name1u
1852
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1857
return tree, expected_dirblocks
1859
def _filter_out(self, raw_dirblocks):
1860
"""Filter out a walkdirs_utf8 result.
1862
stat field is removed, all native paths are converted to unicode
1864
filtered_dirblocks = []
1865
for dirinfo, block in raw_dirblocks:
1866
dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1869
details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1870
filtered_dirblocks.append((dirinfo, details))
1871
return filtered_dirblocks
1873
def test_walk_unicode_tree(self):
1874
self.requireFeature(features.UnicodeFilenameFeature)
1875
tree, expected_dirblocks = self._get_unicode_tree()
1876
self.build_tree(tree)
1877
result = list(osutils._walkdirs_utf8('.'))
1878
self.assertEqual(expected_dirblocks, self._filter_out(result))
1880
def test_symlink(self):
1881
self.requireFeature(features.SymlinkFeature)
1882
self.requireFeature(features.UnicodeFilenameFeature)
1883
target = u'target\N{Euro Sign}'
1884
link_name = u'l\N{Euro Sign}nk'
1885
os.symlink(target, link_name)
1886
target_utf8 = target.encode('UTF-8')
1887
link_name_utf8 = link_name.encode('UTF-8')
1888
expected_dirblocks = [
1890
[(link_name_utf8, link_name_utf8,
1891
'symlink', './' + link_name),],
1893
result = list(osutils._walkdirs_utf8('.'))
1894
self.assertEqual(expected_dirblocks, self._filter_out(result))
1897
class TestReadLink(tests.TestCaseInTempDir):
1898
"""Exposes os.readlink() problems and the osutils solution.
1900
The only guarantee offered by os.readlink(), starting with 2.6, is that a
1901
unicode string will be returned if a unicode string is passed.
1903
But prior python versions failed to properly encode the passed unicode
1906
_test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]
1909
super(tests.TestCaseInTempDir, self).setUp()
1910
self.link = u'l\N{Euro Sign}ink'
1911
self.target = u'targe\N{Euro Sign}t'
1912
os.symlink(self.target, self.link)
1914
def test_os_readlink_link_encoding(self):
1915
self.assertEquals(self.target, os.readlink(self.link))
1917
def test_os_readlink_link_decoding(self):
1918
self.assertEquals(self.target.encode(osutils._fs_enc),
1919
os.readlink(self.link.encode(osutils._fs_enc)))
1922
class TestConcurrency(tests.TestCase):
1925
super(TestConcurrency, self).setUp()
1926
self.overrideAttr(osutils, '_cached_local_concurrency')
1928
def test_local_concurrency(self):
1929
concurrency = osutils.local_concurrency()
1930
self.assertIsInstance(concurrency, int)
1932
def test_local_concurrency_environment_variable(self):
1933
self.overrideEnv('BZR_CONCURRENCY', '2')
1934
self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1935
self.overrideEnv('BZR_CONCURRENCY', '3')
1936
self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1937
self.overrideEnv('BZR_CONCURRENCY', 'foo')
1938
self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1940
def test_option_concurrency(self):
1941
self.overrideEnv('BZR_CONCURRENCY', '1')
1942
self.run_bzr('rocks --concurrency 42')
1943
# Command line overrides environment variable
1944
self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1945
self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1948
class TestFailedToLoadExtension(tests.TestCase):
1950
def _try_loading(self):
1952
import bzrlib._fictional_extension_py
1953
except ImportError, e:
1954
osutils.failed_to_load_extension(e)
1958
super(TestFailedToLoadExtension, self).setUp()
1959
self.overrideAttr(osutils, '_extension_load_failures', [])
1961
def test_failure_to_load(self):
1963
self.assertLength(1, osutils._extension_load_failures)
1964
self.assertEquals(osutils._extension_load_failures[0],
1965
"No module named _fictional_extension_py")
1967
def test_report_extension_load_failures_no_warning(self):
1968
self.assertTrue(self._try_loading())
1969
warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
1970
# it used to give a Python warning; it no longer does
1971
self.assertLength(0, warnings)
1973
def test_report_extension_load_failures_message(self):
1975
trace.push_log_file(log)
1976
self.assertTrue(self._try_loading())
1977
osutils.report_extension_load_failures()
1978
self.assertContainsRe(
1980
r"bzr: warning: some compiled extensions could not be loaded; "
1981
"see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1985
class TestTerminalWidth(tests.TestCase):
1988
tests.TestCase.setUp(self)
1989
self._orig_terminal_size_state = osutils._terminal_size_state
1990
self._orig_first_terminal_size = osutils._first_terminal_size
1991
self.addCleanup(self.restore_osutils_globals)
1992
osutils._terminal_size_state = 'no_data'
1993
osutils._first_terminal_size = None
1995
def restore_osutils_globals(self):
1996
osutils._terminal_size_state = self._orig_terminal_size_state
1997
osutils._first_terminal_size = self._orig_first_terminal_size
1999
def replace_stdout(self, new):
2000
self.overrideAttr(sys, 'stdout', new)
2002
def replace__terminal_size(self, new):
2003
self.overrideAttr(osutils, '_terminal_size', new)
2005
def set_fake_tty(self):
2007
class I_am_a_tty(object):
2011
self.replace_stdout(I_am_a_tty())
2013
def test_default_values(self):
2014
self.assertEqual(80, osutils.default_terminal_width)
2016
def test_defaults_to_BZR_COLUMNS(self):
2017
# BZR_COLUMNS is set by the test framework
2018
self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
2019
self.overrideEnv('BZR_COLUMNS', '12')
2020
self.assertEqual(12, osutils.terminal_width())
2022
def test_BZR_COLUMNS_0_no_limit(self):
2023
self.overrideEnv('BZR_COLUMNS', '0')
2024
self.assertEqual(None, osutils.terminal_width())
2026
def test_falls_back_to_COLUMNS(self):
2027
self.overrideEnv('BZR_COLUMNS', None)
2028
self.assertNotEqual('42', os.environ['COLUMNS'])
2030
self.overrideEnv('COLUMNS', '42')
2031
self.assertEqual(42, osutils.terminal_width())
2033
def test_tty_default_without_columns(self):
2034
self.overrideEnv('BZR_COLUMNS', None)
2035
self.overrideEnv('COLUMNS', None)
2037
def terminal_size(w, h):
2041
# We need to override the osutils definition as it depends on the
2042
# running environment that we can't control (PQM running without a
2043
# controlling terminal is one example).
2044
self.replace__terminal_size(terminal_size)
2045
self.assertEqual(42, osutils.terminal_width())
2047
def test_non_tty_default_without_columns(self):
2048
self.overrideEnv('BZR_COLUMNS', None)
2049
self.overrideEnv('COLUMNS', None)
2050
self.replace_stdout(None)
2051
self.assertEqual(None, osutils.terminal_width())
2053
def test_no_TIOCGWINSZ(self):
2054
self.requireFeature(term_ios_feature)
2055
termios = term_ios_feature.module
2056
# bug 63539 is about a termios without TIOCGWINSZ attribute
2058
orig = termios.TIOCGWINSZ
2059
except AttributeError:
2060
# We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
2063
self.overrideAttr(termios, 'TIOCGWINSZ')
2064
del termios.TIOCGWINSZ
2065
self.overrideEnv('BZR_COLUMNS', None)
2066
self.overrideEnv('COLUMNS', None)
2067
# Whatever the result is, if we don't raise an exception, it's ok.
2068
osutils.terminal_width()
2071
class TestCreationOps(tests.TestCaseInTempDir):
2072
_test_needs_features = [features.chown_feature]
2075
tests.TestCaseInTempDir.setUp(self)
2076
self.overrideAttr(os, 'chown', self._dummy_chown)
2078
# params set by call to _dummy_chown
2079
self.path = self.uid = self.gid = None
2081
def _dummy_chown(self, path, uid, gid):
2082
self.path, self.uid, self.gid = path, uid, gid
2084
def test_copy_ownership_from_path(self):
2085
"""copy_ownership_from_path test with specified src."""
2087
f = open('test_file', 'wt')
2088
osutils.copy_ownership_from_path('test_file', ownsrc)
2091
self.assertEquals(self.path, 'test_file')
2092
self.assertEquals(self.uid, s.st_uid)
2093
self.assertEquals(self.gid, s.st_gid)
2095
def test_copy_ownership_nonesrc(self):
2096
"""copy_ownership_from_path test with src=None."""
2097
f = open('test_file', 'wt')
2098
# should use parent dir for permissions
2099
osutils.copy_ownership_from_path('test_file')
2102
self.assertEquals(self.path, 'test_file')
2103
self.assertEquals(self.uid, s.st_uid)
2104
self.assertEquals(self.gid, s.st_gid)
2107
class TestPathFromEnviron(tests.TestCase):
2109
def test_is_unicode(self):
2110
self.overrideEnv('BZR_TEST_PATH', './anywhere at all/')
2111
path = osutils.path_from_environ('BZR_TEST_PATH')
2112
self.assertIsInstance(path, unicode)
2113
self.assertEqual(u'./anywhere at all/', path)
2115
def test_posix_path_env_ascii(self):
2116
self.overrideEnv('BZR_TEST_PATH', '/tmp')
2117
home = osutils._posix_path_from_environ('BZR_TEST_PATH')
2118
self.assertIsInstance(home, unicode)
2119
self.assertEqual(u'/tmp', home)
2121
def test_posix_path_env_unicode(self):
2122
self.requireFeature(features.ByteStringNamedFilesystem)
2123
self.overrideEnv('BZR_TEST_PATH', '/home/\xa7test')
2124
self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
2125
self.assertEqual(u'/home/\xa7test',
2126
osutils._posix_path_from_environ('BZR_TEST_PATH'))
2127
osutils._fs_enc = "iso8859-5"
2128
self.assertEqual(u'/home/\u0407test',
2129
osutils._posix_path_from_environ('BZR_TEST_PATH'))
2130
osutils._fs_enc = "utf-8"
2131
self.assertRaises(errors.BadFilenameEncoding,
2132
osutils._posix_path_from_environ, 'BZR_TEST_PATH')
2135
class TestGetHomeDir(tests.TestCase):
2137
def test_is_unicode(self):
2138
home = osutils._get_home_dir()
2139
self.assertIsInstance(home, unicode)
2141
def test_posix_homeless(self):
2142
self.overrideEnv('HOME', None)
2143
home = osutils._get_home_dir()
2144
self.assertIsInstance(home, unicode)
2146
def test_posix_home_ascii(self):
2147
self.overrideEnv('HOME', '/home/test')
2148
home = osutils._posix_get_home_dir()
2149
self.assertIsInstance(home, unicode)
2150
self.assertEqual(u'/home/test', home)
2152
def test_posix_home_unicode(self):
2153
self.requireFeature(features.ByteStringNamedFilesystem)
2154
self.overrideEnv('HOME', '/home/\xa7test')
2155
self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
2156
self.assertEqual(u'/home/\xa7test', osutils._posix_get_home_dir())
2157
osutils._fs_enc = "iso8859-5"
2158
self.assertEqual(u'/home/\u0407test', osutils._posix_get_home_dir())
2159
osutils._fs_enc = "utf-8"
2160
self.assertRaises(errors.BadFilenameEncoding,
2161
osutils._posix_get_home_dir)
2164
class TestGetuserUnicode(tests.TestCase):
2166
def test_is_unicode(self):
2167
user = osutils.getuser_unicode()
2168
self.assertIsInstance(user, unicode)
2170
def envvar_to_override(self):
2171
if sys.platform == "win32":
2172
# Disable use of platform calls on windows so envvar is used
2173
self.overrideAttr(win32utils, 'has_ctypes', False)
2174
return 'USERNAME' # only variable used on windows
2175
return 'LOGNAME' # first variable checked by getpass.getuser()
2177
def test_ascii_user(self):
2178
self.overrideEnv(self.envvar_to_override(), 'jrandom')
2179
self.assertEqual(u'jrandom', osutils.getuser_unicode())
2181
def test_unicode_user(self):
2182
ue = osutils.get_user_encoding()
2183
uni_val, env_val = tests.probe_unicode_in_user_encoding()
2185
raise tests.TestSkipped(
2186
'Cannot find a unicode character that works in encoding %s'
2187
% (osutils.get_user_encoding(),))
2188
uni_username = u'jrandom' + uni_val
2189
encoded_username = uni_username.encode(ue)
2190
self.overrideEnv(self.envvar_to_override(), encoded_username)
2191
self.assertEqual(uni_username, osutils.getuser_unicode())
2194
class TestBackupNames(tests.TestCase):
2197
super(TestBackupNames, self).setUp()
2200
def backup_exists(self, name):
2201
return name in self.backups
2203
def available_backup_name(self, name):
2204
backup_name = osutils.available_backup_name(name, self.backup_exists)
2205
self.backups.append(backup_name)
2208
def assertBackupName(self, expected, name):
2209
self.assertEqual(expected, self.available_backup_name(name))
2211
def test_empty(self):
2212
self.assertBackupName('file.~1~', 'file')
2214
def test_existing(self):
2215
self.available_backup_name('file')
2216
self.available_backup_name('file')
2217
self.assertBackupName('file.~3~', 'file')
2218
# Empty slots are found, this is not a strict requirement and may be
2219
# revisited if we test against all implementations.
2220
self.backups.remove('file.~2~')
2221
self.assertBackupName('file.~2~', 'file')
2224
class TestFindExecutableInPath(tests.TestCase):
2226
def test_windows(self):
2227
if sys.platform != 'win32':
2228
raise tests.TestSkipped('test requires win32')
2229
self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
2231
osutils.find_executable_on_path('explorer.exe') is not None)
2233
osutils.find_executable_on_path('EXPLORER.EXE') is not None)
2235
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2236
self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2238
def test_windows_app_path(self):
2239
if sys.platform != 'win32':
2240
raise tests.TestSkipped('test requires win32')
2241
# Override PATH env var so that exe can only be found on App Path
2242
self.overrideEnv('PATH', '')
2243
# Internt Explorer is always registered in the App Path
2244
self.assertTrue(osutils.find_executable_on_path('iexplore') is not None)
2246
def test_other(self):
2247
if sys.platform == 'win32':
2248
raise tests.TestSkipped('test requires non-win32')
2249
self.assertTrue(osutils.find_executable_on_path('sh') is not None)
2251
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2254
class TestEnvironmentErrors(tests.TestCase):
2255
"""Test handling of environmental errors"""
2257
def test_is_oserror(self):
2258
self.assertTrue(osutils.is_environment_error(
2259
OSError(errno.EINVAL, "Invalid parameter")))
2261
def test_is_ioerror(self):
2262
self.assertTrue(osutils.is_environment_error(
2263
IOError(errno.EINVAL, "Invalid parameter")))
2265
def test_is_socket_error(self):
2266
self.assertTrue(osutils.is_environment_error(
2267
socket.error(errno.EINVAL, "Invalid parameter")))
2269
def test_is_select_error(self):
2270
self.assertTrue(osutils.is_environment_error(
2271
select.error(errno.EINVAL, "Invalid parameter")))
2273
def test_is_pywintypes_error(self):
2274
self.requireFeature(features.pywintypes)
2276
self.assertTrue(osutils.is_environment_error(
2277
pywintypes.error(errno.EINVAL, "Invalid parameter", "Caller")))
added
removed
bzrlib/tests/test_osutils.py
