1
# Copyright (C) 2005-2011 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
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
17
"""Tests for the osutils wrapper."""
19
from cStringIO import StringIO
37
from bzrlib.tests import (
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):
106
def test_contains_whitespace(self):
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'))
114
# \xa0 is "Non-breaking-space" which on some python locales thinks it
115
# is whitespace, but we do not.
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)
134
def test_fancy_rename(self):
135
# This should work everywhere
136
self.create_file('a', 'something in a\n')
137
self._fancy_rename('a', 'b')
138
self.assertPathDoesNotExist('a')
139
self.assertPathExists('b')
140
self.check_file_contents('b', 'something in a\n')
142
self.create_file('a', 'new something in a\n')
143
self._fancy_rename('b', 'a')
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')
159
def test_rename(self):
160
# Rename should be semi-atomic on all platforms
161
self.create_file('a', 'something in a\n')
162
osutils.rename('a', 'b')
163
self.assertPathDoesNotExist('a')
164
self.assertPathExists('b')
165
self.check_file_contents('b', 'something in a\n')
167
self.create_file('a', 'new something in a\n')
168
osutils.rename('b', 'a')
170
self.check_file_contents('a', 'something in a\n')
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):
196
def test_01_rand_chars_empty(self):
197
result = osutils.rand_chars(0)
198
self.assertEqual(result, '')
200
def test_02_rand_chars_100(self):
201
result = osutils.rand_chars(100)
202
self.assertEqual(len(result), 100)
203
self.assertEqual(type(result), str)
204
self.assertContainsRe(result, r'^[a-z0-9]{100}$')
207
class TestIsInside(tests.TestCase):
209
def test_is_inside(self):
210
is_inside = osutils.is_inside
211
self.assertTrue(is_inside('src', 'src/foo.c'))
212
self.assertFalse(is_inside('src', 'srccontrol'))
213
self.assertTrue(is_inside('src', 'src/a/a/a/foo.c'))
214
self.assertTrue(is_inside('foo.c', 'foo.c'))
215
self.assertFalse(is_inside('foo.c', ''))
216
self.assertTrue(is_inside('', 'foo.c'))
218
def test_is_inside_any(self):
219
SRC_FOO_C = osutils.pathjoin('src', 'foo.c')
220
for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
221
(['src'], SRC_FOO_C),
224
self.assert_(osutils.is_inside_any(dirs, fn))
225
for dirs, fn in [(['src'], 'srccontrol'),
226
(['src'], 'srccontrol/foo')]:
227
self.assertFalse(osutils.is_inside_any(dirs, fn))
229
def test_is_inside_or_parent_of_any(self):
230
for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
231
(['src'], 'src/foo.c'),
232
(['src/bar.c'], 'src'),
233
(['src/bar.c', 'bla/foo.c'], 'src'),
236
self.assert_(osutils.is_inside_or_parent_of_any(dirs, fn))
238
for dirs, fn in [(['src'], 'srccontrol'),
239
(['srccontrol/foo.c'], 'src'),
240
(['src'], 'srccontrol/foo')]:
241
self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
244
class TestLstat(tests.TestCaseInTempDir):
246
def test_lstat_matches_fstat(self):
247
# On Windows, lstat and fstat don't always agree, primarily in the
248
# 'st_ino' and 'st_dev' fields. So we force them to be '0' in our
249
# custom implementation.
250
if sys.platform == 'win32':
251
# We only have special lstat/fstat if we have the extension.
252
# Without it, we may end up re-reading content when we don't have
253
# to, but otherwise it doesn't effect correctness.
254
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
255
f = open('test-file.txt', 'wb')
256
self.addCleanup(f.close)
257
f.write('some content\n')
259
self.assertEqualStat(osutils.fstat(f.fileno()),
260
osutils.lstat('test-file.txt'))
263
class TestRmTree(tests.TestCaseInTempDir):
265
def test_rmtree(self):
266
# Check to remove tree with read-only files/dirs
268
f = file('dir/file', 'w')
271
# would like to also try making the directory readonly, but at the
272
# moment python shutil.rmtree doesn't handle that properly - it would
273
# need to chmod the directory before removing things inside it - deferred
274
# for now -- mbp 20060505
275
# osutils.make_readonly('dir')
276
osutils.make_readonly('dir/file')
278
osutils.rmtree('dir')
280
self.assertPathDoesNotExist('dir/file')
281
self.assertPathDoesNotExist('dir')
284
class TestDeleteAny(tests.TestCaseInTempDir):
286
def test_delete_any_readonly(self):
287
# from <https://bugs.launchpad.net/bzr/+bug/218206>
288
self.build_tree(['d/', 'f'])
289
osutils.make_readonly('d')
290
osutils.make_readonly('f')
292
osutils.delete_any('f')
293
osutils.delete_any('d')
296
class TestKind(tests.TestCaseInTempDir):
298
def test_file_kind(self):
299
self.build_tree(['file', 'dir/'])
300
self.assertEquals('file', osutils.file_kind('file'))
301
self.assertEquals('directory', osutils.file_kind('dir/'))
302
if osutils.has_symlinks():
303
os.symlink('symlink', 'symlink')
304
self.assertEquals('symlink', osutils.file_kind('symlink'))
306
# TODO: jam 20060529 Test a block device
308
os.lstat('/dev/null')
310
if e.errno not in (errno.ENOENT,):
313
self.assertEquals('chardev', osutils.file_kind('/dev/null'))
315
mkfifo = getattr(os, 'mkfifo', None)
319
self.assertEquals('fifo', osutils.file_kind('fifo'))
323
AF_UNIX = getattr(socket, 'AF_UNIX', None)
325
s = socket.socket(AF_UNIX)
328
self.assertEquals('socket', osutils.file_kind('socket'))
332
def test_kind_marker(self):
333
self.assertEqual("", osutils.kind_marker("file"))
334
self.assertEqual("/", osutils.kind_marker('directory'))
335
self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
336
self.assertEqual("@", osutils.kind_marker("symlink"))
337
self.assertEqual("+", osutils.kind_marker("tree-reference"))
338
self.assertEqual("", osutils.kind_marker("fifo"))
339
self.assertEqual("", osutils.kind_marker("socket"))
340
self.assertEqual("", osutils.kind_marker("unknown"))
343
class TestUmask(tests.TestCaseInTempDir):
345
def test_get_umask(self):
346
if sys.platform == 'win32':
347
# umask always returns '0', no way to set it
348
self.assertEqual(0, osutils.get_umask())
351
orig_umask = osutils.get_umask()
352
self.addCleanup(os.umask, orig_umask)
354
self.assertEqual(0222, osutils.get_umask())
356
self.assertEqual(0022, osutils.get_umask())
358
self.assertEqual(0002, osutils.get_umask())
360
self.assertEqual(0027, osutils.get_umask())
363
class TestDateTime(tests.TestCase):
365
def assertFormatedDelta(self, expected, seconds):
366
"""Assert osutils.format_delta formats as expected"""
367
actual = osutils.format_delta(seconds)
368
self.assertEqual(expected, actual)
370
def test_format_delta(self):
371
self.assertFormatedDelta('0 seconds ago', 0)
372
self.assertFormatedDelta('1 second ago', 1)
373
self.assertFormatedDelta('10 seconds ago', 10)
374
self.assertFormatedDelta('59 seconds ago', 59)
375
self.assertFormatedDelta('89 seconds ago', 89)
376
self.assertFormatedDelta('1 minute, 30 seconds ago', 90)
377
self.assertFormatedDelta('3 minutes, 0 seconds ago', 180)
378
self.assertFormatedDelta('3 minutes, 1 second ago', 181)
379
self.assertFormatedDelta('10 minutes, 15 seconds ago', 615)
380
self.assertFormatedDelta('30 minutes, 59 seconds ago', 1859)
381
self.assertFormatedDelta('31 minutes, 0 seconds ago', 1860)
382
self.assertFormatedDelta('60 minutes, 0 seconds ago', 3600)
383
self.assertFormatedDelta('89 minutes, 59 seconds ago', 5399)
384
self.assertFormatedDelta('1 hour, 30 minutes ago', 5400)
385
self.assertFormatedDelta('2 hours, 30 minutes ago', 9017)
386
self.assertFormatedDelta('10 hours, 0 minutes ago', 36000)
387
self.assertFormatedDelta('24 hours, 0 minutes ago', 86400)
388
self.assertFormatedDelta('35 hours, 59 minutes ago', 129599)
389
self.assertFormatedDelta('36 hours, 0 minutes ago', 129600)
390
self.assertFormatedDelta('36 hours, 0 minutes ago', 129601)
391
self.assertFormatedDelta('36 hours, 1 minute ago', 129660)
392
self.assertFormatedDelta('36 hours, 1 minute ago', 129661)
393
self.assertFormatedDelta('84 hours, 10 minutes ago', 303002)
395
# We handle when time steps the wrong direction because computers
396
# don't have synchronized clocks.
397
self.assertFormatedDelta('84 hours, 10 minutes in the future', -303002)
398
self.assertFormatedDelta('1 second in the future', -1)
399
self.assertFormatedDelta('2 seconds in the future', -2)
401
def test_format_date(self):
402
self.assertRaises(errors.UnsupportedTimezoneFormat,
403
osutils.format_date, 0, timezone='foo')
404
self.assertIsInstance(osutils.format_date(0), str)
405
self.assertIsInstance(osutils.format_local_date(0), unicode)
406
# Testing for the actual value of the local weekday without
407
# duplicating the code from format_date is difficult.
408
# Instead blackbox.test_locale should check for localized
409
# dates once they do occur in output strings.
411
def test_format_date_with_offset_in_original_timezone(self):
412
self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
413
osutils.format_date_with_offset_in_original_timezone(0))
414
self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
415
osutils.format_date_with_offset_in_original_timezone(100000))
416
self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
417
osutils.format_date_with_offset_in_original_timezone(100000, 7200))
419
def test_local_time_offset(self):
420
"""Test that local_time_offset() returns a sane value."""
421
offset = osutils.local_time_offset()
422
self.assertTrue(isinstance(offset, int))
423
# Test that the offset is no more than a eighteen hours in
425
# Time zone handling is system specific, so it is difficult to
426
# do more specific tests, but a value outside of this range is
428
eighteen_hours = 18 * 3600
429
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
431
def test_local_time_offset_with_timestamp(self):
432
"""Test that local_time_offset() works with a timestamp."""
433
offset = osutils.local_time_offset(1000000000.1234567)
434
self.assertTrue(isinstance(offset, int))
435
eighteen_hours = 18 * 3600
436
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
439
class TestLinks(tests.TestCaseInTempDir):
441
def test_dereference_path(self):
442
self.requireFeature(features.SymlinkFeature)
443
cwd = osutils.realpath('.')
445
bar_path = osutils.pathjoin(cwd, 'bar')
446
# Using './' to avoid bug #1213894 (first path component not
447
# dereferenced) in Python 2.4.1 and earlier
448
self.assertEqual(bar_path, osutils.realpath('./bar'))
449
os.symlink('bar', 'foo')
450
self.assertEqual(bar_path, osutils.realpath('./foo'))
452
# Does not dereference terminal symlinks
453
foo_path = osutils.pathjoin(cwd, 'foo')
454
self.assertEqual(foo_path, osutils.dereference_path('./foo'))
456
# Dereferences parent symlinks
458
baz_path = osutils.pathjoin(bar_path, 'baz')
459
self.assertEqual(baz_path, osutils.dereference_path('./foo/baz'))
461
# Dereferences parent symlinks that are the first path element
462
self.assertEqual(baz_path, osutils.dereference_path('foo/baz'))
464
# Dereferences parent symlinks in absolute paths
465
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
466
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
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
super(TestPumpFile, self).setUp()
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):
739
def test_from_ascii_string(self):
740
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
742
def test_from_unicode_string_ascii_contents(self):
743
self.assertEqual(u'bargam', osutils.safe_unicode(u'bargam'))
745
def test_from_unicode_string_unicode_contents(self):
746
self.assertEqual(u'bargam\xae', osutils.safe_unicode(u'bargam\xae'))
748
def test_from_utf8_string(self):
749
self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
751
def test_bad_utf8_string(self):
752
self.assertRaises(errors.BzrBadParameterNotUnicode,
753
osutils.safe_unicode,
757
class TestSafeUtf8(tests.TestCase):
759
def test_from_ascii_string(self):
761
self.assertEqual('foobar', osutils.safe_utf8(f))
763
def test_from_unicode_string_ascii_contents(self):
764
self.assertEqual('bargam', osutils.safe_utf8(u'bargam'))
766
def test_from_unicode_string_unicode_contents(self):
767
self.assertEqual('bargam\xc2\xae', osutils.safe_utf8(u'bargam\xae'))
769
def test_from_utf8_string(self):
770
self.assertEqual('foo\xc2\xae', osutils.safe_utf8('foo\xc2\xae'))
772
def test_bad_utf8_string(self):
773
self.assertRaises(errors.BzrBadParameterNotUnicode,
774
osutils.safe_utf8, '\xbb\xbb')
777
class TestSafeRevisionId(tests.TestCase):
779
def test_from_ascii_string(self):
780
# this shouldn't give a warning because it's getting an ascii string
781
self.assertEqual('foobar', osutils.safe_revision_id('foobar'))
783
def test_from_unicode_string_ascii_contents(self):
784
self.assertEqual('bargam',
785
osutils.safe_revision_id(u'bargam', warn=False))
787
def test_from_unicode_deprecated(self):
788
self.assertEqual('bargam',
789
self.callDeprecated([osutils._revision_id_warning],
790
osutils.safe_revision_id, u'bargam'))
792
def test_from_unicode_string_unicode_contents(self):
793
self.assertEqual('bargam\xc2\xae',
794
osutils.safe_revision_id(u'bargam\xae', warn=False))
796
def test_from_utf8_string(self):
797
self.assertEqual('foo\xc2\xae',
798
osutils.safe_revision_id('foo\xc2\xae'))
801
"""Currently, None is a valid revision_id"""
802
self.assertEqual(None, osutils.safe_revision_id(None))
805
class TestSafeFileId(tests.TestCase):
807
def test_from_ascii_string(self):
808
self.assertEqual('foobar', osutils.safe_file_id('foobar'))
810
def test_from_unicode_string_ascii_contents(self):
811
self.assertEqual('bargam', osutils.safe_file_id(u'bargam', warn=False))
813
def test_from_unicode_deprecated(self):
814
self.assertEqual('bargam',
815
self.callDeprecated([osutils._file_id_warning],
816
osutils.safe_file_id, u'bargam'))
818
def test_from_unicode_string_unicode_contents(self):
819
self.assertEqual('bargam\xc2\xae',
820
osutils.safe_file_id(u'bargam\xae', warn=False))
822
def test_from_utf8_string(self):
823
self.assertEqual('foo\xc2\xae',
824
osutils.safe_file_id('foo\xc2\xae'))
827
"""Currently, None is a valid revision_id"""
828
self.assertEqual(None, osutils.safe_file_id(None))
831
class TestPosixFuncs(tests.TestCase):
832
"""Test that the posix version of normpath returns an appropriate path
833
when used with 2 leading slashes."""
835
def test_normpath(self):
836
self.assertEqual('/etc/shadow', osutils._posix_normpath('/etc/shadow'))
837
self.assertEqual('/etc/shadow', osutils._posix_normpath('//etc/shadow'))
838
self.assertEqual('/etc/shadow', osutils._posix_normpath('///etc/shadow'))
841
class TestWin32Funcs(tests.TestCase):
842
"""Test that _win32 versions of os utilities return appropriate paths."""
844
def test_abspath(self):
845
self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
846
self.assertEqual('C:/foo', osutils._win32_abspath('C:/foo'))
847
self.assertEqual('//HOST/path', osutils._win32_abspath(r'\\HOST\path'))
848
self.assertEqual('//HOST/path', osutils._win32_abspath('//HOST/path'))
850
def test_realpath(self):
851
self.assertEqual('C:/foo', osutils._win32_realpath('C:\\foo'))
852
self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
854
def test_pathjoin(self):
855
self.assertEqual('path/to/foo',
856
osutils._win32_pathjoin('path', 'to', 'foo'))
857
self.assertEqual('C:/foo',
858
osutils._win32_pathjoin('path\\to', 'C:\\foo'))
859
self.assertEqual('C:/foo',
860
osutils._win32_pathjoin('path/to', 'C:/foo'))
861
self.assertEqual('path/to/foo',
862
osutils._win32_pathjoin('path/to/', 'foo'))
863
self.assertEqual('/foo',
864
osutils._win32_pathjoin('C:/path/to/', '/foo'))
865
self.assertEqual('/foo',
866
osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
868
def test_normpath(self):
869
self.assertEqual('path/to/foo',
870
osutils._win32_normpath(r'path\\from\..\to\.\foo'))
871
self.assertEqual('path/to/foo',
872
osutils._win32_normpath('path//from/../to/./foo'))
874
def test_getcwd(self):
875
cwd = osutils._win32_getcwd()
876
os_cwd = os.getcwdu()
877
self.assertEqual(os_cwd[1:].replace('\\', '/'), cwd[1:])
878
# win32 is inconsistent whether it returns lower or upper case
879
# and even if it was consistent the user might type the other
880
# so we force it to uppercase
881
# running python.exe under cmd.exe return capital C:\\
882
# running win32 python inside a cygwin shell returns lowercase
883
self.assertEqual(os_cwd[0].upper(), cwd[0])
885
def test_fixdrive(self):
886
self.assertEqual('H:/foo', osutils._win32_fixdrive('h:/foo'))
887
self.assertEqual('H:/foo', osutils._win32_fixdrive('H:/foo'))
888
self.assertEqual('C:\\foo', osutils._win32_fixdrive('c:\\foo'))
890
def test_win98_abspath(self):
892
self.assertEqual('C:/foo', osutils._win98_abspath('C:\\foo'))
893
self.assertEqual('C:/foo', osutils._win98_abspath('C:/foo'))
895
self.assertEqual('//HOST/path', osutils._win98_abspath(r'\\HOST\path'))
896
self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
898
cwd = osutils.getcwd().rstrip('/')
899
drive = osutils.ntpath.splitdrive(cwd)[0]
900
self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
901
self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
904
self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
907
class TestWin32FuncsDirs(tests.TestCaseInTempDir):
908
"""Test win32 functions that create files."""
910
def test_getcwd(self):
911
self.requireFeature(features.UnicodeFilenameFeature)
914
# TODO: jam 20060427 This will probably fail on Mac OSX because
915
# it will change the normalization of B\xe5gfors
916
# Consider using a different unicode character, or make
917
# osutils.getcwd() renormalize the path.
918
self.assertEndsWith(osutils._win32_getcwd(), u'mu-\xb5')
920
def test_minimum_path_selection(self):
921
self.assertEqual(set(),
922
osutils.minimum_path_selection([]))
923
self.assertEqual(set(['a']),
924
osutils.minimum_path_selection(['a']))
925
self.assertEqual(set(['a', 'b']),
926
osutils.minimum_path_selection(['a', 'b']))
927
self.assertEqual(set(['a/', 'b']),
928
osutils.minimum_path_selection(['a/', 'b']))
929
self.assertEqual(set(['a/', 'b']),
930
osutils.minimum_path_selection(['a/c', 'a/', 'b']))
931
self.assertEqual(set(['a-b', 'a', 'a0b']),
932
osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
934
def test_mkdtemp(self):
935
tmpdir = osutils._win32_mkdtemp(dir='.')
936
self.assertFalse('\\' in tmpdir)
938
def test_rename(self):
946
osutils._win32_rename('b', 'a')
947
self.assertPathExists('a')
948
self.assertPathDoesNotExist('b')
949
self.assertFileEqual('baz\n', 'a')
951
def test_rename_missing_file(self):
957
osutils._win32_rename('b', 'a')
958
except (IOError, OSError), e:
959
self.assertEqual(errno.ENOENT, e.errno)
960
self.assertFileEqual('foo\n', 'a')
962
def test_rename_missing_dir(self):
965
osutils._win32_rename('b', 'a')
966
except (IOError, OSError), e:
967
self.assertEqual(errno.ENOENT, e.errno)
969
def test_rename_current_dir(self):
972
# You can't rename the working directory
973
# doing rename non-existant . usually
974
# just raises ENOENT, since non-existant
977
osutils._win32_rename('b', '.')
978
except (IOError, OSError), e:
979
self.assertEqual(errno.ENOENT, e.errno)
981
def test_splitpath(self):
982
def check(expected, path):
983
self.assertEqual(expected, osutils.splitpath(path))
986
check(['a', 'b'], 'a/b')
987
check(['a', 'b'], 'a/./b')
988
check(['a', '.b'], 'a/.b')
989
check(['a', '.b'], 'a\\.b')
991
self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
994
class TestParentDirectories(tests.TestCaseInTempDir):
995
"""Test osutils.parent_directories()"""
997
def test_parent_directories(self):
998
self.assertEqual([], osutils.parent_directories('a'))
999
self.assertEqual(['a'], osutils.parent_directories('a/b'))
1000
self.assertEqual(['a/b', 'a'], osutils.parent_directories('a/b/c'))
1003
class TestMacFuncsDirs(tests.TestCaseInTempDir):
1004
"""Test mac special functions that require directories."""
1006
def test_getcwd(self):
1007
self.requireFeature(features.UnicodeFilenameFeature)
1008
os.mkdir(u'B\xe5gfors')
1009
os.chdir(u'B\xe5gfors')
1010
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
1012
def test_getcwd_nonnorm(self):
1013
self.requireFeature(features.UnicodeFilenameFeature)
1014
# Test that _mac_getcwd() will normalize this path
1015
os.mkdir(u'Ba\u030agfors')
1016
os.chdir(u'Ba\u030agfors')
1017
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
1020
class TestChunksToLines(tests.TestCase):
1022
def test_smoketest(self):
1023
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
1024
osutils.chunks_to_lines(['foo\nbar', '\nbaz\n']))
1025
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
1026
osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
1028
def test_osutils_binding(self):
1029
from bzrlib.tests import test__chunks_to_lines
1030
if test__chunks_to_lines.compiled_chunkstolines_feature.available():
1031
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1033
from bzrlib._chunks_to_lines_py import chunks_to_lines
1034
self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
1037
class TestSplitLines(tests.TestCase):
1039
def test_split_unicode(self):
1040
self.assertEqual([u'foo\n', u'bar\xae'],
1041
osutils.split_lines(u'foo\nbar\xae'))
1042
self.assertEqual([u'foo\n', u'bar\xae\n'],
1043
osutils.split_lines(u'foo\nbar\xae\n'))
1045
def test_split_with_carriage_returns(self):
1046
self.assertEqual(['foo\rbar\n'],
1047
osutils.split_lines('foo\rbar\n'))
1050
class TestWalkDirs(tests.TestCaseInTempDir):
1052
def assertExpectedBlocks(self, expected, result):
1053
self.assertEqual(expected,
1054
[(dirinfo, [line[0:3] for line in block])
1055
for dirinfo, block in result])
1057
def test_walkdirs(self):
1066
self.build_tree(tree)
1067
expected_dirblocks = [
1069
[('0file', '0file', 'file'),
1070
('1dir', '1dir', 'directory'),
1071
('2file', '2file', 'file'),
1074
(('1dir', './1dir'),
1075
[('1dir/0file', '0file', 'file'),
1076
('1dir/1dir', '1dir', 'directory'),
1079
(('1dir/1dir', './1dir/1dir'),
1085
found_bzrdir = False
1086
for dirdetail, dirblock in osutils.walkdirs('.'):
1087
if len(dirblock) and dirblock[0][1] == '.bzr':
1088
# this tests the filtering of selected paths
1091
result.append((dirdetail, dirblock))
1093
self.assertTrue(found_bzrdir)
1094
self.assertExpectedBlocks(expected_dirblocks, result)
1095
# you can search a subdir only, with a supplied prefix.
1097
for dirblock in osutils.walkdirs('./1dir', '1dir'):
1098
result.append(dirblock)
1099
self.assertExpectedBlocks(expected_dirblocks[1:], result)
1101
def test_walkdirs_os_error(self):
1102
# <https://bugs.launchpad.net/bzr/+bug/338653>
1103
# Pyrex readdir didn't raise useful messages if it had an error
1104
# reading the directory
1105
if sys.platform == 'win32':
1106
raise tests.TestNotApplicable(
1107
"readdir IOError not tested on win32")
1108
self.requireFeature(features.not_running_as_root)
1109
os.mkdir("test-unreadable")
1110
os.chmod("test-unreadable", 0000)
1111
# must chmod it back so that it can be removed
1112
self.addCleanup(os.chmod, "test-unreadable", 0700)
1113
# The error is not raised until the generator is actually evaluated.
1114
# (It would be ok if it happened earlier but at the moment it
1116
e = self.assertRaises(OSError, list, osutils._walkdirs_utf8("."))
1117
self.assertEquals('./test-unreadable', e.filename)
1118
self.assertEquals(errno.EACCES, e.errno)
1119
# Ensure the message contains the file name
1120
self.assertContainsRe(str(e), "\./test-unreadable")
1123
def test_walkdirs_encoding_error(self):
1124
# <https://bugs.launchpad.net/bzr/+bug/488519>
1125
# walkdirs didn't raise a useful message when the filenames
1126
# are not using the filesystem's encoding
1128
# require a bytestring based filesystem
1129
self.requireFeature(features.ByteStringNamedFilesystem)
1140
self.build_tree(tree)
1142
# rename the 1file to a latin-1 filename
1143
os.rename("./1file", "\xe8file")
1144
if "\xe8file" not in os.listdir("."):
1145
self.skip("Lack filesystem that preserves arbitrary bytes")
1147
self._save_platform_info()
1148
win32utils.winver = None # Avoid the win32 detection code
1149
osutils._fs_enc = 'UTF-8'
1151
# this should raise on error
1153
for dirdetail, dirblock in osutils.walkdirs('.'):
1156
self.assertRaises(errors.BadFilenameEncoding, attempt)
1158
def test__walkdirs_utf8(self):
1167
self.build_tree(tree)
1168
expected_dirblocks = [
1170
[('0file', '0file', 'file'),
1171
('1dir', '1dir', 'directory'),
1172
('2file', '2file', 'file'),
1175
(('1dir', './1dir'),
1176
[('1dir/0file', '0file', 'file'),
1177
('1dir/1dir', '1dir', 'directory'),
1180
(('1dir/1dir', './1dir/1dir'),
1186
found_bzrdir = False
1187
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1188
if len(dirblock) and dirblock[0][1] == '.bzr':
1189
# this tests the filtering of selected paths
1192
result.append((dirdetail, dirblock))
1194
self.assertTrue(found_bzrdir)
1195
self.assertExpectedBlocks(expected_dirblocks, result)
1197
# you can search a subdir only, with a supplied prefix.
1199
for dirblock in osutils.walkdirs('./1dir', '1dir'):
1200
result.append(dirblock)
1201
self.assertExpectedBlocks(expected_dirblocks[1:], result)
1203
def _filter_out_stat(self, result):
1204
"""Filter out the stat value from the walkdirs result"""
1205
for dirdetail, dirblock in result:
1207
for info in dirblock:
1208
# Ignore info[3] which is the stat
1209
new_dirblock.append((info[0], info[1], info[2], info[4]))
1210
dirblock[:] = new_dirblock
1212
def _save_platform_info(self):
1213
self.overrideAttr(win32utils, 'winver')
1214
self.overrideAttr(osutils, '_fs_enc')
1215
self.overrideAttr(osutils, '_selected_dir_reader')
1217
def assertDirReaderIs(self, expected):
1218
"""Assert the right implementation for _walkdirs_utf8 is chosen."""
1219
# Force it to redetect
1220
osutils._selected_dir_reader = None
1221
# Nothing to list, but should still trigger the selection logic
1222
self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
1223
self.assertIsInstance(osutils._selected_dir_reader, expected)
1225
def test_force_walkdirs_utf8_fs_utf8(self):
1226
self.requireFeature(UTF8DirReaderFeature)
1227
self._save_platform_info()
1228
win32utils.winver = None # Avoid the win32 detection code
1229
osutils._fs_enc = 'utf-8'
1230
self.assertDirReaderIs(
1231
UTF8DirReaderFeature.module.UTF8DirReader)
1233
def test_force_walkdirs_utf8_fs_ascii(self):
1234
self.requireFeature(UTF8DirReaderFeature)
1235
self._save_platform_info()
1236
win32utils.winver = None # Avoid the win32 detection code
1237
osutils._fs_enc = 'ascii'
1238
self.assertDirReaderIs(
1239
UTF8DirReaderFeature.module.UTF8DirReader)
1241
def test_force_walkdirs_utf8_fs_latin1(self):
1242
self._save_platform_info()
1243
win32utils.winver = None # Avoid the win32 detection code
1244
osutils._fs_enc = 'iso-8859-1'
1245
self.assertDirReaderIs(osutils.UnicodeDirReader)
1247
def test_force_walkdirs_utf8_nt(self):
1248
# Disabled because the thunk of the whole walkdirs api is disabled.
1249
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1250
self._save_platform_info()
1251
win32utils.winver = 'Windows NT'
1252
from bzrlib._walkdirs_win32 import Win32ReadDir
1253
self.assertDirReaderIs(Win32ReadDir)
1255
def test_force_walkdirs_utf8_98(self):
1256
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1257
self._save_platform_info()
1258
win32utils.winver = 'Windows 98'
1259
self.assertDirReaderIs(osutils.UnicodeDirReader)
1261
def test_unicode_walkdirs(self):
1262
"""Walkdirs should always return unicode paths."""
1263
self.requireFeature(features.UnicodeFilenameFeature)
1264
name0 = u'0file-\xb6'
1265
name1 = u'1dir-\u062c\u0648'
1266
name2 = u'2file-\u0633'
1270
name1 + '/' + name0,
1271
name1 + '/' + name1 + '/',
1274
self.build_tree(tree)
1275
expected_dirblocks = [
1277
[(name0, name0, 'file', './' + name0),
1278
(name1, name1, 'directory', './' + name1),
1279
(name2, name2, 'file', './' + name2),
1282
((name1, './' + name1),
1283
[(name1 + '/' + name0, name0, 'file', './' + name1
1285
(name1 + '/' + name1, name1, 'directory', './' + name1
1289
((name1 + '/' + name1, './' + name1 + '/' + name1),
1294
result = list(osutils.walkdirs('.'))
1295
self._filter_out_stat(result)
1296
self.assertEqual(expected_dirblocks, result)
1297
result = list(osutils.walkdirs(u'./'+name1, name1))
1298
self._filter_out_stat(result)
1299
self.assertEqual(expected_dirblocks[1:], result)
1301
def test_unicode__walkdirs_utf8(self):
1302
"""Walkdirs_utf8 should always return utf8 paths.
1304
The abspath portion might be in unicode or utf-8
1306
self.requireFeature(features.UnicodeFilenameFeature)
1307
name0 = u'0file-\xb6'
1308
name1 = u'1dir-\u062c\u0648'
1309
name2 = u'2file-\u0633'
1313
name1 + '/' + name0,
1314
name1 + '/' + name1 + '/',
1317
self.build_tree(tree)
1318
name0 = name0.encode('utf8')
1319
name1 = name1.encode('utf8')
1320
name2 = name2.encode('utf8')
1322
expected_dirblocks = [
1324
[(name0, name0, 'file', './' + name0),
1325
(name1, name1, 'directory', './' + name1),
1326
(name2, name2, 'file', './' + name2),
1329
((name1, './' + name1),
1330
[(name1 + '/' + name0, name0, 'file', './' + name1
1332
(name1 + '/' + name1, name1, 'directory', './' + name1
1336
((name1 + '/' + name1, './' + name1 + '/' + name1),
1342
# For ease in testing, if walkdirs_utf8 returns Unicode, assert that
1343
# all abspaths are Unicode, and encode them back into utf8.
1344
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1345
self.assertIsInstance(dirdetail[0], str)
1346
if isinstance(dirdetail[1], unicode):
1347
dirdetail = (dirdetail[0], dirdetail[1].encode('utf8'))
1348
dirblock = [list(info) for info in dirblock]
1349
for info in dirblock:
1350
self.assertIsInstance(info[4], unicode)
1351
info[4] = info[4].encode('utf8')
1353
for info in dirblock:
1354
self.assertIsInstance(info[0], str)
1355
self.assertIsInstance(info[1], str)
1356
self.assertIsInstance(info[4], str)
1357
# Remove the stat information
1358
new_dirblock.append((info[0], info[1], info[2], info[4]))
1359
result.append((dirdetail, new_dirblock))
1360
self.assertEqual(expected_dirblocks, result)
1362
def test__walkdirs_utf8_with_unicode_fs(self):
1363
"""UnicodeDirReader should be a safe fallback everywhere
1365
The abspath portion should be in unicode
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')
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'
1498
name0 = name0u.encode('utf8')
1499
self.build_tree([name0u + '/'])
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])
1507
def assertPathCompare(self, path_less, path_greater):
1508
"""check that path_less and path_greater compare correctly."""
1509
self.assertEqual(0, osutils.compare_paths_prefix_order(
1510
path_less, path_less))
1511
self.assertEqual(0, osutils.compare_paths_prefix_order(
1512
path_greater, path_greater))
1513
self.assertEqual(-1, osutils.compare_paths_prefix_order(
1514
path_less, path_greater))
1515
self.assertEqual(1, osutils.compare_paths_prefix_order(
1516
path_greater, path_less))
1518
def test_compare_paths_prefix_order(self):
1519
# root before all else
1520
self.assertPathCompare("/", "/a")
1521
# alpha within a dir
1522
self.assertPathCompare("/a", "/b")
1523
self.assertPathCompare("/b", "/z")
1524
# high dirs before lower.
1525
self.assertPathCompare("/z", "/a/a")
1526
# except if the deeper dir should be output first
1527
self.assertPathCompare("/a/b/c", "/d/g")
1528
# lexical betwen dirs of the same height
1529
self.assertPathCompare("/a/z", "/z/z")
1530
self.assertPathCompare("/a/c/z", "/a/d/e")
1532
# this should also be consistent for no leading / paths
1533
# root before all else
1534
self.assertPathCompare("", "a")
1535
# alpha within a dir
1536
self.assertPathCompare("a", "b")
1537
self.assertPathCompare("b", "z")
1538
# high dirs before lower.
1539
self.assertPathCompare("z", "a/a")
1540
# except if the deeper dir should be output first
1541
self.assertPathCompare("a/b/c", "d/g")
1542
# lexical betwen dirs of the same height
1543
self.assertPathCompare("a/z", "z/z")
1544
self.assertPathCompare("a/c/z", "a/d/e")
1546
def test_path_prefix_sorting(self):
1547
"""Doing a sort on path prefix should match our sample data."""
1562
dir_sorted_paths = [
1578
sorted(original_paths, key=osutils.path_prefix_key))
1579
# using the comparison routine shoudl work too:
1582
sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
1585
class TestCopyTree(tests.TestCaseInTempDir):
1587
def test_copy_basic_tree(self):
1588
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1589
osutils.copy_tree('source', 'target')
1590
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1591
self.assertEqual(['c'], os.listdir('target/b'))
1593
def test_copy_tree_target_exists(self):
1594
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c',
1596
osutils.copy_tree('source', 'target')
1597
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1598
self.assertEqual(['c'], os.listdir('target/b'))
1600
def test_copy_tree_symlinks(self):
1601
self.requireFeature(features.SymlinkFeature)
1602
self.build_tree(['source/'])
1603
os.symlink('a/generic/path', 'source/lnk')
1604
osutils.copy_tree('source', 'target')
1605
self.assertEqual(['lnk'], os.listdir('target'))
1606
self.assertEqual('a/generic/path', os.readlink('target/lnk'))
1608
def test_copy_tree_handlers(self):
1609
processed_files = []
1610
processed_links = []
1611
def file_handler(from_path, to_path):
1612
processed_files.append(('f', from_path, to_path))
1613
def dir_handler(from_path, to_path):
1614
processed_files.append(('d', from_path, to_path))
1615
def link_handler(from_path, to_path):
1616
processed_links.append((from_path, to_path))
1617
handlers = {'file':file_handler,
1618
'directory':dir_handler,
1619
'symlink':link_handler,
1622
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1623
if osutils.has_symlinks():
1624
os.symlink('a/generic/path', 'source/lnk')
1625
osutils.copy_tree('source', 'target', handlers=handlers)
1627
self.assertEqual([('d', 'source', 'target'),
1628
('f', 'source/a', 'target/a'),
1629
('d', 'source/b', 'target/b'),
1630
('f', 'source/b/c', 'target/b/c'),
1632
self.assertPathDoesNotExist('target')
1633
if osutils.has_symlinks():
1634
self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1637
class TestSetUnsetEnv(tests.TestCase):
1638
"""Test updating the environment"""
1641
super(TestSetUnsetEnv, self).setUp()
1643
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
1644
'Environment was not cleaned up properly.'
1645
' Variable BZR_TEST_ENV_VAR should not exist.')
1647
if 'BZR_TEST_ENV_VAR' in os.environ:
1648
del os.environ['BZR_TEST_ENV_VAR']
1649
self.addCleanup(cleanup)
1652
"""Test that we can set an env variable"""
1653
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1654
self.assertEqual(None, old)
1655
self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
1657
def test_double_set(self):
1658
"""Test that we get the old value out"""
1659
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1660
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
1661
self.assertEqual('foo', old)
1662
self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
1664
def test_unicode(self):
1665
"""Environment can only contain plain strings
1667
So Unicode strings must be encoded.
1669
uni_val, env_val = tests.probe_unicode_in_user_encoding()
1671
raise tests.TestSkipped(
1672
'Cannot find a unicode character that works in encoding %s'
1673
% (osutils.get_user_encoding(),))
1675
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1676
self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
1678
def test_unset(self):
1679
"""Test that passing None will remove the env var"""
1680
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1681
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1682
self.assertEqual('foo', old)
1683
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
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
super(TestDirReader, self).setUp()
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
super(TestTerminalWidth, self).setUp()
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
super(TestCreationOps, self).setUp()
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
