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
27
from bzrlib import (
31
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
32
36
from bzrlib.tests import (
40
class TestOSUtils(TestCaseInTempDir):
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):
42
105
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'))
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
113
# \xa0 is "Non-breaking-space" which on some python locales thinks it
51
114
# 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'))
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)
56
133
def test_fancy_rename(self):
57
134
# 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')
135
self.create_file('a', 'something in a\n')
136
self._fancy_rename('a', 'b')
137
self.assertPathDoesNotExist('a')
138
self.assertPathExists('b')
67
139
self.check_file_contents('b', 'something in a\n')
69
open('a', 'wb').write('new something in a\n')
141
self.create_file('a', 'new something in a\n')
142
self._fancy_rename('b', 'a')
72
144
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')
74
158
def test_rename(self):
75
159
# Rename should be semi-atomic on all platforms
76
open('a', 'wb').write('something in a\n')
160
self.create_file('a', 'something in a\n')
77
161
osutils.rename('a', 'b')
78
self.failIfExists('a')
79
self.failUnlessExists('b')
162
self.assertPathDoesNotExist('a')
163
self.assertPathExists('b')
80
164
self.check_file_contents('b', 'something in a\n')
82
open('a', 'wb').write('new something in a\n')
166
self.create_file('a', 'new something in a\n')
83
167
osutils.rename('b', 'a')
85
169
self.check_file_contents('a', 'something in a\n')
87
171
# TODO: test fancy_rename using a MemoryTransport
173
def test_rename_change_case(self):
174
# on Windows we should be able to change filename case by rename
175
self.build_tree(['a', 'b/'])
176
osutils.rename('a', 'A')
177
osutils.rename('b', 'B')
178
# we can't use failUnlessExists on case-insensitive filesystem
179
# so try to check shape of the tree
180
shape = sorted(os.listdir('.'))
181
self.assertEquals(['A', 'B'], shape)
184
class TestRandChars(tests.TestCase):
89
186
def test_01_rand_chars_empty(self):
90
187
result = osutils.rand_chars(0)
91
188
self.assertEqual(result, '')
246
455
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
247
456
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
250
def test_kind_marker(self):
251
self.assertEqual("", osutils.kind_marker("file"))
252
self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
253
self.assertEqual("@", osutils.kind_marker("symlink"))
254
self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
257
class TestSafeUnicode(TestCase):
458
def test_changing_access(self):
459
f = file('file', 'w')
463
# Make a file readonly
464
osutils.make_readonly('file')
465
mode = os.lstat('file').st_mode
466
self.assertEqual(mode, mode & 0777555)
468
# Make a file writable
469
osutils.make_writable('file')
470
mode = os.lstat('file').st_mode
471
self.assertEqual(mode, mode | 0200)
473
if osutils.has_symlinks():
474
# should not error when handed a symlink
475
os.symlink('nonexistent', 'dangling')
476
osutils.make_readonly('dangling')
477
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):
259
729
def test_from_ascii_string(self):
260
730
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
732
1347
result.append((dirdetail, new_dirblock))
733
1348
self.assertEqual(expected_dirblocks, result)
735
def test_unicode__walkdirs_unicode_to_utf8(self):
736
"""walkdirs_unicode_to_utf8 should be a safe fallback everywhere
1350
def test__walkdirs_utf8_with_unicode_fs(self):
1351
"""UnicodeDirReader should be a safe fallback everywhere
738
1353
The abspath portion should be in unicode
740
name0u = u'0file-\xb6'
741
name1u = u'1dir-\u062c\u0648'
742
name2u = u'2file-\u0633'
746
name1u + '/' + name0u,
747
name1u + '/' + name1u + '/',
1355
self.requireFeature(features.UnicodeFilenameFeature)
1356
# Use the unicode reader. TODO: split into driver-and-driven unit
1358
self._save_platform_info()
1359
osutils._selected_dir_reader = osutils.UnicodeDirReader()
1360
name0u = u'0file-\xb6'
1361
name1u = u'1dir-\u062c\u0648'
1362
name2u = u'2file-\u0633'
1366
name1u + '/' + name0u,
1367
name1u + '/' + name1u + '/',
1370
self.build_tree(tree)
1371
name0 = name0u.encode('utf8')
1372
name1 = name1u.encode('utf8')
1373
name2 = name2u.encode('utf8')
1375
# All of the abspaths should be in unicode, all of the relative paths
1377
expected_dirblocks = [
1379
[(name0, name0, 'file', './' + name0u),
1380
(name1, name1, 'directory', './' + name1u),
1381
(name2, name2, 'file', './' + name2u),
1384
((name1, './' + name1u),
1385
[(name1 + '/' + name0, name0, 'file', './' + name1u
1387
(name1 + '/' + name1, name1, 'directory', './' + name1u
1391
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1396
result = list(osutils._walkdirs_utf8('.'))
1397
self._filter_out_stat(result)
1398
self.assertEqual(expected_dirblocks, result)
1400
def test__walkdirs_utf8_win32readdir(self):
1401
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1402
self.requireFeature(features.UnicodeFilenameFeature)
1403
from bzrlib._walkdirs_win32 import Win32ReadDir
1404
self._save_platform_info()
1405
osutils._selected_dir_reader = Win32ReadDir()
1406
name0u = u'0file-\xb6'
1407
name1u = u'1dir-\u062c\u0648'
1408
name2u = u'2file-\u0633'
1412
name1u + '/' + name0u,
1413
name1u + '/' + name1u + '/',
1416
self.build_tree(tree)
1417
name0 = name0u.encode('utf8')
1418
name1 = name1u.encode('utf8')
1419
name2 = name2u.encode('utf8')
1421
# All of the abspaths should be in unicode, all of the relative paths
1423
expected_dirblocks = [
1425
[(name0, name0, 'file', './' + name0u),
1426
(name1, name1, 'directory', './' + name1u),
1427
(name2, name2, 'file', './' + name2u),
1430
((name1, './' + name1u),
1431
[(name1 + '/' + name0, name0, 'file', './' + name1u
1433
(name1 + '/' + name1, name1, 'directory', './' + name1u
1437
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1442
result = list(osutils._walkdirs_utf8(u'.'))
1443
self._filter_out_stat(result)
1444
self.assertEqual(expected_dirblocks, result)
1446
def assertStatIsCorrect(self, path, win32stat):
1447
os_stat = os.stat(path)
1448
self.assertEqual(os_stat.st_size, win32stat.st_size)
1449
self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
1450
self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
1451
self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
1452
self.assertEqual(os_stat.st_dev, win32stat.st_dev)
1453
self.assertEqual(os_stat.st_ino, win32stat.st_ino)
1454
self.assertEqual(os_stat.st_mode, win32stat.st_mode)
1456
def test__walkdirs_utf_win32_find_file_stat_file(self):
1457
"""make sure our Stat values are valid"""
1458
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1459
self.requireFeature(features.UnicodeFilenameFeature)
1460
from bzrlib._walkdirs_win32 import Win32ReadDir
1461
name0u = u'0file-\xb6'
1462
name0 = name0u.encode('utf8')
1463
self.build_tree([name0u])
1464
# I hate to sleep() here, but I'm trying to make the ctime different
1467
f = open(name0u, 'ab')
751
self.build_tree(tree)
753
raise TestSkipped('Could not represent Unicode chars'
754
' in current encoding.')
1469
f.write('just a small update')
1473
result = Win32ReadDir().read_dir('', u'.')
1475
self.assertEqual((name0, name0, 'file'), entry[:3])
1476
self.assertEqual(u'./' + name0u, entry[4])
1477
self.assertStatIsCorrect(entry[4], entry[3])
1478
self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
1480
def test__walkdirs_utf_win32_find_file_stat_directory(self):
1481
"""make sure our Stat values are valid"""
1482
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1483
self.requireFeature(features.UnicodeFilenameFeature)
1484
from bzrlib._walkdirs_win32 import Win32ReadDir
1485
name0u = u'0dir-\u062c\u0648'
755
1486
name0 = name0u.encode('utf8')
756
name1 = name1u.encode('utf8')
757
name2 = name2u.encode('utf8')
1487
self.build_tree([name0u + '/'])
759
# All of the abspaths should be in unicode, all of the relative paths
761
expected_dirblocks = [
763
[(name0, name0, 'file', './' + name0u),
764
(name1, name1, 'directory', './' + name1u),
765
(name2, name2, 'file', './' + name2u),
768
((name1, './' + name1u),
769
[(name1 + '/' + name0, name0, 'file', './' + name1u
771
(name1 + '/' + name1, name1, 'directory', './' + name1u
775
((name1 + '/' + name1, './' + name1u + '/' + name1u),
780
result = list(osutils._walkdirs_unicode_to_utf8('.'))
781
self._filter_out_stat(result)
782
self.assertEqual(expected_dirblocks, result)
1489
result = Win32ReadDir().read_dir('', u'.')
1491
self.assertEqual((name0, name0, 'directory'), entry[:3])
1492
self.assertEqual(u'./' + name0u, entry[4])
1493
self.assertStatIsCorrect(entry[4], entry[3])
784
1495
def assertPathCompare(self, path_less, path_greater):
785
1496
"""check that path_less and path_greater compare correctly."""
973
1669
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
974
1670
self.assertEqual('foo', old)
975
1671
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
976
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
979
class TestLocalTimeOffset(TestCase):
981
def test_local_time_offset(self):
982
"""Test that local_time_offset() returns a sane value."""
983
offset = osutils.local_time_offset()
984
self.assertTrue(isinstance(offset, int))
985
# Test that the offset is no more than a eighteen hours in
987
# Time zone handling is system specific, so it is difficult to
988
# do more specific tests, but a value outside of this range is
990
eighteen_hours = 18 * 3600
991
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
993
def test_local_time_offset_with_timestamp(self):
994
"""Test that local_time_offset() works with a timestamp."""
995
offset = osutils.local_time_offset(1000000000.1234567)
996
self.assertTrue(isinstance(offset, int))
997
eighteen_hours = 18 * 3600
998
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1672
self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
1675
class TestSizeShaFile(tests.TestCaseInTempDir):
1677
def test_sha_empty(self):
1678
self.build_tree_contents([('foo', '')])
1679
expected_sha = osutils.sha_string('')
1681
self.addCleanup(f.close)
1682
size, sha = osutils.size_sha_file(f)
1683
self.assertEqual(0, size)
1684
self.assertEqual(expected_sha, sha)
1686
def test_sha_mixed_endings(self):
1687
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1688
self.build_tree_contents([('foo', text)])
1689
expected_sha = osutils.sha_string(text)
1690
f = open('foo', 'rb')
1691
self.addCleanup(f.close)
1692
size, sha = osutils.size_sha_file(f)
1693
self.assertEqual(38, size)
1694
self.assertEqual(expected_sha, sha)
1697
class TestShaFileByName(tests.TestCaseInTempDir):
1699
def test_sha_empty(self):
1700
self.build_tree_contents([('foo', '')])
1701
expected_sha = osutils.sha_string('')
1702
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1704
def test_sha_mixed_endings(self):
1705
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1706
self.build_tree_contents([('foo', text)])
1707
expected_sha = osutils.sha_string(text)
1708
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1711
class TestResourceLoading(tests.TestCaseInTempDir):
1713
def test_resource_string(self):
1714
# test resource in bzrlib
1715
text = osutils.resource_string('bzrlib', 'debug.py')
1716
self.assertContainsRe(text, "debug_flags = set()")
1717
# test resource under bzrlib
1718
text = osutils.resource_string('bzrlib.ui', 'text.py')
1719
self.assertContainsRe(text, "class TextUIFactory")
1720
# test unsupported package
1721
self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1723
# test unknown resource
1724
self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1727
class TestReCompile(tests.TestCase):
1729
def _deprecated_re_compile_checked(self, *args, **kwargs):
1730
return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
1731
osutils.re_compile_checked, *args, **kwargs)
1733
def test_re_compile_checked(self):
1734
r = self._deprecated_re_compile_checked(r'A*', re.IGNORECASE)
1735
self.assertTrue(r.match('aaaa'))
1736
self.assertTrue(r.match('aAaA'))
1738
def test_re_compile_checked_error(self):
1739
# like https://bugs.launchpad.net/bzr/+bug/251352
1741
# Due to possible test isolation error, re.compile is not lazy at
1742
# this point. We re-install lazy compile.
1743
lazy_regex.install_lazy_compile()
1744
err = self.assertRaises(
1745
errors.BzrCommandError,
1746
self._deprecated_re_compile_checked, '*', re.IGNORECASE, 'test case')
1748
'Invalid regular expression in test case: '
1749
'"*" nothing to repeat',
1753
class TestDirReader(tests.TestCaseInTempDir):
1755
scenarios = dir_reader_scenarios()
1758
_dir_reader_class = None
1759
_native_to_unicode = None
1762
tests.TestCaseInTempDir.setUp(self)
1763
self.overrideAttr(osutils,
1764
'_selected_dir_reader', self._dir_reader_class())
1766
def _get_ascii_tree(self):
1774
expected_dirblocks = [
1776
[('0file', '0file', 'file'),
1777
('1dir', '1dir', 'directory'),
1778
('2file', '2file', 'file'),
1781
(('1dir', './1dir'),
1782
[('1dir/0file', '0file', 'file'),
1783
('1dir/1dir', '1dir', 'directory'),
1786
(('1dir/1dir', './1dir/1dir'),
1791
return tree, expected_dirblocks
1793
def test_walk_cur_dir(self):
1794
tree, expected_dirblocks = self._get_ascii_tree()
1795
self.build_tree(tree)
1796
result = list(osutils._walkdirs_utf8('.'))
1797
# Filter out stat and abspath
1798
self.assertEqual(expected_dirblocks,
1799
[(dirinfo, [line[0:3] for line in block])
1800
for dirinfo, block in result])
1802
def test_walk_sub_dir(self):
1803
tree, expected_dirblocks = self._get_ascii_tree()
1804
self.build_tree(tree)
1805
# you can search a subdir only, with a supplied prefix.
1806
result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1807
# Filter out stat and abspath
1808
self.assertEqual(expected_dirblocks[1:],
1809
[(dirinfo, [line[0:3] for line in block])
1810
for dirinfo, block in result])
1812
def _get_unicode_tree(self):
1813
name0u = u'0file-\xb6'
1814
name1u = u'1dir-\u062c\u0648'
1815
name2u = u'2file-\u0633'
1819
name1u + '/' + name0u,
1820
name1u + '/' + name1u + '/',
1823
name0 = name0u.encode('UTF-8')
1824
name1 = name1u.encode('UTF-8')
1825
name2 = name2u.encode('UTF-8')
1826
expected_dirblocks = [
1828
[(name0, name0, 'file', './' + name0u),
1829
(name1, name1, 'directory', './' + name1u),
1830
(name2, name2, 'file', './' + name2u),
1833
((name1, './' + name1u),
1834
[(name1 + '/' + name0, name0, 'file', './' + name1u
1836
(name1 + '/' + name1, name1, 'directory', './' + name1u
1840
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1845
return tree, expected_dirblocks
1847
def _filter_out(self, raw_dirblocks):
1848
"""Filter out a walkdirs_utf8 result.
1850
stat field is removed, all native paths are converted to unicode
1852
filtered_dirblocks = []
1853
for dirinfo, block in raw_dirblocks:
1854
dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1857
details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1858
filtered_dirblocks.append((dirinfo, details))
1859
return filtered_dirblocks
1861
def test_walk_unicode_tree(self):
1862
self.requireFeature(features.UnicodeFilenameFeature)
1863
tree, expected_dirblocks = self._get_unicode_tree()
1864
self.build_tree(tree)
1865
result = list(osutils._walkdirs_utf8('.'))
1866
self.assertEqual(expected_dirblocks, self._filter_out(result))
1868
def test_symlink(self):
1869
self.requireFeature(features.SymlinkFeature)
1870
self.requireFeature(features.UnicodeFilenameFeature)
1871
target = u'target\N{Euro Sign}'
1872
link_name = u'l\N{Euro Sign}nk'
1873
os.symlink(target, link_name)
1874
target_utf8 = target.encode('UTF-8')
1875
link_name_utf8 = link_name.encode('UTF-8')
1876
expected_dirblocks = [
1878
[(link_name_utf8, link_name_utf8,
1879
'symlink', './' + link_name),],
1881
result = list(osutils._walkdirs_utf8('.'))
1882
self.assertEqual(expected_dirblocks, self._filter_out(result))
1885
class TestReadLink(tests.TestCaseInTempDir):
1886
"""Exposes os.readlink() problems and the osutils solution.
1888
The only guarantee offered by os.readlink(), starting with 2.6, is that a
1889
unicode string will be returned if a unicode string is passed.
1891
But prior python versions failed to properly encode the passed unicode
1894
_test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]
1897
super(tests.TestCaseInTempDir, self).setUp()
1898
self.link = u'l\N{Euro Sign}ink'
1899
self.target = u'targe\N{Euro Sign}t'
1900
os.symlink(self.target, self.link)
1902
def test_os_readlink_link_encoding(self):
1903
self.assertEquals(self.target, os.readlink(self.link))
1905
def test_os_readlink_link_decoding(self):
1906
self.assertEquals(self.target.encode(osutils._fs_enc),
1907
os.readlink(self.link.encode(osutils._fs_enc)))
1910
class TestConcurrency(tests.TestCase):
1913
super(TestConcurrency, self).setUp()
1914
self.overrideAttr(osutils, '_cached_local_concurrency')
1916
def test_local_concurrency(self):
1917
concurrency = osutils.local_concurrency()
1918
self.assertIsInstance(concurrency, int)
1920
def test_local_concurrency_environment_variable(self):
1921
self.overrideEnv('BZR_CONCURRENCY', '2')
1922
self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1923
self.overrideEnv('BZR_CONCURRENCY', '3')
1924
self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1925
self.overrideEnv('BZR_CONCURRENCY', 'foo')
1926
self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1928
def test_option_concurrency(self):
1929
self.overrideEnv('BZR_CONCURRENCY', '1')
1930
self.run_bzr('rocks --concurrency 42')
1931
# Command line overrides environment variable
1932
self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1933
self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1936
class TestFailedToLoadExtension(tests.TestCase):
1938
def _try_loading(self):
1940
import bzrlib._fictional_extension_py
1941
except ImportError, e:
1942
osutils.failed_to_load_extension(e)
1946
super(TestFailedToLoadExtension, self).setUp()
1947
self.overrideAttr(osutils, '_extension_load_failures', [])
1949
def test_failure_to_load(self):
1951
self.assertLength(1, osutils._extension_load_failures)
1952
self.assertEquals(osutils._extension_load_failures[0],
1953
"No module named _fictional_extension_py")
1955
def test_report_extension_load_failures_no_warning(self):
1956
self.assertTrue(self._try_loading())
1957
warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
1958
# it used to give a Python warning; it no longer does
1959
self.assertLength(0, warnings)
1961
def test_report_extension_load_failures_message(self):
1963
trace.push_log_file(log)
1964
self.assertTrue(self._try_loading())
1965
osutils.report_extension_load_failures()
1966
self.assertContainsRe(
1968
r"bzr: warning: some compiled extensions could not be loaded; "
1969
"see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1973
class TestTerminalWidth(tests.TestCase):
1976
tests.TestCase.setUp(self)
1977
self._orig_terminal_size_state = osutils._terminal_size_state
1978
self._orig_first_terminal_size = osutils._first_terminal_size
1979
self.addCleanup(self.restore_osutils_globals)
1980
osutils._terminal_size_state = 'no_data'
1981
osutils._first_terminal_size = None
1983
def restore_osutils_globals(self):
1984
osutils._terminal_size_state = self._orig_terminal_size_state
1985
osutils._first_terminal_size = self._orig_first_terminal_size
1987
def replace_stdout(self, new):
1988
self.overrideAttr(sys, 'stdout', new)
1990
def replace__terminal_size(self, new):
1991
self.overrideAttr(osutils, '_terminal_size', new)
1993
def set_fake_tty(self):
1995
class I_am_a_tty(object):
1999
self.replace_stdout(I_am_a_tty())
2001
def test_default_values(self):
2002
self.assertEqual(80, osutils.default_terminal_width)
2004
def test_defaults_to_BZR_COLUMNS(self):
2005
# BZR_COLUMNS is set by the test framework
2006
self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
2007
self.overrideEnv('BZR_COLUMNS', '12')
2008
self.assertEqual(12, osutils.terminal_width())
2010
def test_BZR_COLUMNS_0_no_limit(self):
2011
self.overrideEnv('BZR_COLUMNS', '0')
2012
self.assertEqual(None, osutils.terminal_width())
2014
def test_falls_back_to_COLUMNS(self):
2015
self.overrideEnv('BZR_COLUMNS', None)
2016
self.assertNotEqual('42', os.environ['COLUMNS'])
2018
self.overrideEnv('COLUMNS', '42')
2019
self.assertEqual(42, osutils.terminal_width())
2021
def test_tty_default_without_columns(self):
2022
self.overrideEnv('BZR_COLUMNS', None)
2023
self.overrideEnv('COLUMNS', None)
2025
def terminal_size(w, h):
2029
# We need to override the osutils definition as it depends on the
2030
# running environment that we can't control (PQM running without a
2031
# controlling terminal is one example).
2032
self.replace__terminal_size(terminal_size)
2033
self.assertEqual(42, osutils.terminal_width())
2035
def test_non_tty_default_without_columns(self):
2036
self.overrideEnv('BZR_COLUMNS', None)
2037
self.overrideEnv('COLUMNS', None)
2038
self.replace_stdout(None)
2039
self.assertEqual(None, osutils.terminal_width())
2041
def test_no_TIOCGWINSZ(self):
2042
self.requireFeature(term_ios_feature)
2043
termios = term_ios_feature.module
2044
# bug 63539 is about a termios without TIOCGWINSZ attribute
2046
orig = termios.TIOCGWINSZ
2047
except AttributeError:
2048
# We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
2051
self.overrideAttr(termios, 'TIOCGWINSZ')
2052
del termios.TIOCGWINSZ
2053
self.overrideEnv('BZR_COLUMNS', None)
2054
self.overrideEnv('COLUMNS', None)
2055
# Whatever the result is, if we don't raise an exception, it's ok.
2056
osutils.terminal_width()
2059
class TestCreationOps(tests.TestCaseInTempDir):
2060
_test_needs_features = [features.chown_feature]
2063
tests.TestCaseInTempDir.setUp(self)
2064
self.overrideAttr(os, 'chown', self._dummy_chown)
2066
# params set by call to _dummy_chown
2067
self.path = self.uid = self.gid = None
2069
def _dummy_chown(self, path, uid, gid):
2070
self.path, self.uid, self.gid = path, uid, gid
2072
def test_copy_ownership_from_path(self):
2073
"""copy_ownership_from_path test with specified src."""
2075
f = open('test_file', 'wt')
2076
osutils.copy_ownership_from_path('test_file', ownsrc)
2079
self.assertEquals(self.path, 'test_file')
2080
self.assertEquals(self.uid, s.st_uid)
2081
self.assertEquals(self.gid, s.st_gid)
2083
def test_copy_ownership_nonesrc(self):
2084
"""copy_ownership_from_path test with src=None."""
2085
f = open('test_file', 'wt')
2086
# should use parent dir for permissions
2087
osutils.copy_ownership_from_path('test_file')
2090
self.assertEquals(self.path, 'test_file')
2091
self.assertEquals(self.uid, s.st_uid)
2092
self.assertEquals(self.gid, s.st_gid)
2095
class TestGetuserUnicode(tests.TestCase):
2097
def test_ascii_user(self):
2098
self.overrideEnv('LOGNAME', 'jrandom')
2099
self.assertEqual(u'jrandom', osutils.getuser_unicode())
2101
def test_unicode_user(self):
2102
ue = osutils.get_user_encoding()
2103
uni_val, env_val = tests.probe_unicode_in_user_encoding()
2105
raise tests.TestSkipped(
2106
'Cannot find a unicode character that works in encoding %s'
2107
% (osutils.get_user_encoding(),))
2108
uni_username = u'jrandom' + uni_val
2109
encoded_username = uni_username.encode(ue)
2110
self.overrideEnv('LOGNAME', encoded_username)
2111
self.assertEqual(uni_username, osutils.getuser_unicode())
2112
self.overrideEnv('LOGNAME', u'jrandom\xb6'.encode(ue))
2113
self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())
2115
def test_no_username_bug_660174(self):
2116
self.requireFeature(features.win32_feature)
2117
for name in ('LOGNAME', 'USER', 'LNAME', 'USERNAME'):
2118
self.overrideEnv(name, None)
2119
self.assertEqual(u'UNKNOWN', osutils.getuser_unicode())
2122
class TestBackupNames(tests.TestCase):
2125
super(TestBackupNames, self).setUp()
2128
def backup_exists(self, name):
2129
return name in self.backups
2131
def available_backup_name(self, name):
2132
backup_name = osutils.available_backup_name(name, self.backup_exists)
2133
self.backups.append(backup_name)
2136
def assertBackupName(self, expected, name):
2137
self.assertEqual(expected, self.available_backup_name(name))
2139
def test_empty(self):
2140
self.assertBackupName('file.~1~', 'file')
2142
def test_existing(self):
2143
self.available_backup_name('file')
2144
self.available_backup_name('file')
2145
self.assertBackupName('file.~3~', 'file')
2146
# Empty slots are found, this is not a strict requirement and may be
2147
# revisited if we test against all implementations.
2148
self.backups.remove('file.~2~')
2149
self.assertBackupName('file.~2~', 'file')
2152
class TestFindExecutableInPath(tests.TestCase):
2154
def test_windows(self):
2155
if sys.platform != 'win32':
2156
raise tests.TestSkipped('test requires win32')
2157
self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
2159
osutils.find_executable_on_path('explorer.exe') is not None)
2161
osutils.find_executable_on_path('EXPLORER.EXE') is not None)
2163
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2164
self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2166
def test_other(self):
2167
if sys.platform == 'win32':
2168
raise tests.TestSkipped('test requires non-win32')
2169
self.assertTrue(osutils.find_executable_on_path('sh') is not None)
2171
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
added
removed
bzrlib/tests/test_osutils.py
