1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
34
from bzrlib.tests import (
40
class _UTF8DirReaderFeature(tests.Feature):
44
from bzrlib import _readdir_pyx
45
self.reader = _readdir_pyx.UTF8DirReader
50
def feature_name(self):
51
return 'bzrlib._readdir_pyx'
53
UTF8DirReaderFeature = _UTF8DirReaderFeature()
56
def _already_unicode(s):
60
def _fs_enc_to_unicode(s):
61
return s.decode(osutils._fs_enc)
64
def _utf8_to_unicode(s):
65
return s.decode('UTF-8')
68
def dir_reader_scenarios():
69
# For each dir reader we define:
71
# - native_to_unicode: a function converting the native_abspath as returned
72
# by DirReader.read_dir to its unicode representation
74
# UnicodeDirReader is the fallback, it should be tested on all platforms.
75
scenarios = [('unicode',
76
dict(_dir_reader_class=osutils.UnicodeDirReader,
77
_native_to_unicode=_already_unicode))]
78
# Some DirReaders are platform specific and even there they may not be
80
if UTF8DirReaderFeature.available():
81
from bzrlib import _readdir_pyx
82
scenarios.append(('utf8',
83
dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
84
_native_to_unicode=_utf8_to_unicode)))
86
if test__walkdirs_win32.Win32ReadDirFeature.available():
88
from bzrlib import _walkdirs_win32
89
# TODO: check on windows, it may be that we need to use/add
90
# safe_unicode instead of _fs_enc_to_unicode
93
dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
94
_native_to_unicode=_fs_enc_to_unicode)))
100
def load_tests(basic_tests, module, loader):
101
suite = loader.suiteClass()
102
dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
103
basic_tests, tests.condition_isinstance(TestDirReader))
104
tests.multiply_tests(dir_reader_tests, dir_reader_scenarios(), suite)
105
suite.addTest(remaining_tests)
109
class TestContainsWhitespace(tests.TestCase):
111
def test_contains_whitespace(self):
112
self.failUnless(osutils.contains_whitespace(u' '))
113
self.failUnless(osutils.contains_whitespace(u'hello there'))
114
self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
115
self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
116
self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
117
self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
119
# \xa0 is "Non-breaking-space" which on some python locales thinks it
120
# is whitespace, but we do not.
121
self.failIf(osutils.contains_whitespace(u''))
122
self.failIf(osutils.contains_whitespace(u'hellothere'))
123
self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
126
class TestRename(tests.TestCaseInTempDir):
128
def test_fancy_rename(self):
129
# This should work everywhere
131
osutils.fancy_rename(a, b,
132
rename_func=os.rename,
133
unlink_func=os.unlink)
135
open('a', 'wb').write('something in a\n')
137
self.failIfExists('a')
138
self.failUnlessExists('b')
139
self.check_file_contents('b', 'something in a\n')
141
open('a', 'wb').write('new something in a\n')
144
self.check_file_contents('a', 'something in a\n')
146
def test_rename(self):
147
# Rename should be semi-atomic on all platforms
148
open('a', 'wb').write('something in a\n')
149
osutils.rename('a', 'b')
150
self.failIfExists('a')
151
self.failUnlessExists('b')
152
self.check_file_contents('b', 'something in a\n')
154
open('a', 'wb').write('new something in a\n')
155
osutils.rename('b', 'a')
157
self.check_file_contents('a', 'something in a\n')
159
# TODO: test fancy_rename using a MemoryTransport
161
def test_rename_change_case(self):
162
# on Windows we should be able to change filename case by rename
163
self.build_tree(['a', 'b/'])
164
osutils.rename('a', 'A')
165
osutils.rename('b', 'B')
166
# we can't use failUnlessExists on case-insensitive filesystem
167
# so try to check shape of the tree
168
shape = sorted(os.listdir('.'))
169
self.assertEquals(['A', 'B'], shape)
172
class TestRandChars(tests.TestCase):
174
def test_01_rand_chars_empty(self):
175
result = osutils.rand_chars(0)
176
self.assertEqual(result, '')
178
def test_02_rand_chars_100(self):
179
result = osutils.rand_chars(100)
180
self.assertEqual(len(result), 100)
181
self.assertEqual(type(result), str)
182
self.assertContainsRe(result, r'^[a-z0-9]{100}$')
185
class TestIsInside(tests.TestCase):
187
def test_is_inside(self):
188
is_inside = osutils.is_inside
189
self.assertTrue(is_inside('src', 'src/foo.c'))
190
self.assertFalse(is_inside('src', 'srccontrol'))
191
self.assertTrue(is_inside('src', 'src/a/a/a/foo.c'))
192
self.assertTrue(is_inside('foo.c', 'foo.c'))
193
self.assertFalse(is_inside('foo.c', ''))
194
self.assertTrue(is_inside('', 'foo.c'))
196
def test_is_inside_any(self):
197
SRC_FOO_C = osutils.pathjoin('src', 'foo.c')
198
for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
199
(['src'], SRC_FOO_C),
202
self.assert_(osutils.is_inside_any(dirs, fn))
203
for dirs, fn in [(['src'], 'srccontrol'),
204
(['src'], 'srccontrol/foo')]:
205
self.assertFalse(osutils.is_inside_any(dirs, fn))
207
def test_is_inside_or_parent_of_any(self):
208
for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
209
(['src'], 'src/foo.c'),
210
(['src/bar.c'], 'src'),
211
(['src/bar.c', 'bla/foo.c'], 'src'),
214
self.assert_(osutils.is_inside_or_parent_of_any(dirs, fn))
216
for dirs, fn in [(['src'], 'srccontrol'),
217
(['srccontrol/foo.c'], 'src'),
218
(['src'], 'srccontrol/foo')]:
219
self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
222
class TestRmTree(tests.TestCaseInTempDir):
224
def test_rmtree(self):
225
# Check to remove tree with read-only files/dirs
227
f = file('dir/file', 'w')
230
# would like to also try making the directory readonly, but at the
231
# moment python shutil.rmtree doesn't handle that properly - it would
232
# need to chmod the directory before removing things inside it - deferred
233
# for now -- mbp 20060505
234
# osutils.make_readonly('dir')
235
osutils.make_readonly('dir/file')
237
osutils.rmtree('dir')
239
self.failIfExists('dir/file')
240
self.failIfExists('dir')
243
class TestDeleteAny(tests.TestCaseInTempDir):
245
def test_delete_any_readonly(self):
246
# from <https://bugs.launchpad.net/bzr/+bug/218206>
247
self.build_tree(['d/', 'f'])
248
osutils.make_readonly('d')
249
osutils.make_readonly('f')
251
osutils.delete_any('f')
252
osutils.delete_any('d')
255
class TestKind(tests.TestCaseInTempDir):
257
def test_file_kind(self):
258
self.build_tree(['file', 'dir/'])
259
self.assertEquals('file', osutils.file_kind('file'))
260
self.assertEquals('directory', osutils.file_kind('dir/'))
261
if osutils.has_symlinks():
262
os.symlink('symlink', 'symlink')
263
self.assertEquals('symlink', osutils.file_kind('symlink'))
265
# TODO: jam 20060529 Test a block device
267
os.lstat('/dev/null')
269
if e.errno not in (errno.ENOENT,):
272
self.assertEquals('chardev', osutils.file_kind('/dev/null'))
274
mkfifo = getattr(os, 'mkfifo', None)
278
self.assertEquals('fifo', osutils.file_kind('fifo'))
282
AF_UNIX = getattr(socket, 'AF_UNIX', None)
284
s = socket.socket(AF_UNIX)
287
self.assertEquals('socket', osutils.file_kind('socket'))
291
def test_kind_marker(self):
292
self.assertEqual("", osutils.kind_marker("file"))
293
self.assertEqual("/", osutils.kind_marker('directory'))
294
self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
295
self.assertEqual("@", osutils.kind_marker("symlink"))
296
self.assertEqual("+", osutils.kind_marker("tree-reference"))
297
self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
300
class TestUmask(tests.TestCaseInTempDir):
302
def test_get_umask(self):
303
if sys.platform == 'win32':
304
# umask always returns '0', no way to set it
305
self.assertEqual(0, osutils.get_umask())
308
orig_umask = osutils.get_umask()
309
self.addCleanup(os.umask, orig_umask)
311
self.assertEqual(0222, osutils.get_umask())
313
self.assertEqual(0022, osutils.get_umask())
315
self.assertEqual(0002, osutils.get_umask())
317
self.assertEqual(0027, osutils.get_umask())
320
class TestDateTime(tests.TestCase):
322
def assertFormatedDelta(self, expected, seconds):
323
"""Assert osutils.format_delta formats as expected"""
324
actual = osutils.format_delta(seconds)
325
self.assertEqual(expected, actual)
327
def test_format_delta(self):
328
self.assertFormatedDelta('0 seconds ago', 0)
329
self.assertFormatedDelta('1 second ago', 1)
330
self.assertFormatedDelta('10 seconds ago', 10)
331
self.assertFormatedDelta('59 seconds ago', 59)
332
self.assertFormatedDelta('89 seconds ago', 89)
333
self.assertFormatedDelta('1 minute, 30 seconds ago', 90)
334
self.assertFormatedDelta('3 minutes, 0 seconds ago', 180)
335
self.assertFormatedDelta('3 minutes, 1 second ago', 181)
336
self.assertFormatedDelta('10 minutes, 15 seconds ago', 615)
337
self.assertFormatedDelta('30 minutes, 59 seconds ago', 1859)
338
self.assertFormatedDelta('31 minutes, 0 seconds ago', 1860)
339
self.assertFormatedDelta('60 minutes, 0 seconds ago', 3600)
340
self.assertFormatedDelta('89 minutes, 59 seconds ago', 5399)
341
self.assertFormatedDelta('1 hour, 30 minutes ago', 5400)
342
self.assertFormatedDelta('2 hours, 30 minutes ago', 9017)
343
self.assertFormatedDelta('10 hours, 0 minutes ago', 36000)
344
self.assertFormatedDelta('24 hours, 0 minutes ago', 86400)
345
self.assertFormatedDelta('35 hours, 59 minutes ago', 129599)
346
self.assertFormatedDelta('36 hours, 0 minutes ago', 129600)
347
self.assertFormatedDelta('36 hours, 0 minutes ago', 129601)
348
self.assertFormatedDelta('36 hours, 1 minute ago', 129660)
349
self.assertFormatedDelta('36 hours, 1 minute ago', 129661)
350
self.assertFormatedDelta('84 hours, 10 minutes ago', 303002)
352
# We handle when time steps the wrong direction because computers
353
# don't have synchronized clocks.
354
self.assertFormatedDelta('84 hours, 10 minutes in the future', -303002)
355
self.assertFormatedDelta('1 second in the future', -1)
356
self.assertFormatedDelta('2 seconds in the future', -2)
358
def test_format_date(self):
359
self.assertRaises(errors.UnsupportedTimezoneFormat,
360
osutils.format_date, 0, timezone='foo')
361
self.assertIsInstance(osutils.format_date(0), str)
362
self.assertIsInstance(osutils.format_local_date(0), unicode)
363
# Testing for the actual value of the local weekday without
364
# duplicating the code from format_date is difficult.
365
# Instead blackbox.test_locale should check for localized
366
# dates once they do occur in output strings.
368
def test_local_time_offset(self):
369
"""Test that local_time_offset() returns a sane value."""
370
offset = osutils.local_time_offset()
371
self.assertTrue(isinstance(offset, int))
372
# Test that the offset is no more than a eighteen hours in
374
# Time zone handling is system specific, so it is difficult to
375
# do more specific tests, but a value outside of this range is
377
eighteen_hours = 18 * 3600
378
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
380
def test_local_time_offset_with_timestamp(self):
381
"""Test that local_time_offset() works with a timestamp."""
382
offset = osutils.local_time_offset(1000000000.1234567)
383
self.assertTrue(isinstance(offset, int))
384
eighteen_hours = 18 * 3600
385
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
388
class TestLinks(tests.TestCaseInTempDir):
390
def test_dereference_path(self):
391
self.requireFeature(tests.SymlinkFeature)
392
cwd = osutils.realpath('.')
394
bar_path = osutils.pathjoin(cwd, 'bar')
395
# Using './' to avoid bug #1213894 (first path component not
396
# dereferenced) in Python 2.4.1 and earlier
397
self.assertEqual(bar_path, osutils.realpath('./bar'))
398
os.symlink('bar', 'foo')
399
self.assertEqual(bar_path, osutils.realpath('./foo'))
401
# Does not dereference terminal symlinks
402
foo_path = osutils.pathjoin(cwd, 'foo')
403
self.assertEqual(foo_path, osutils.dereference_path('./foo'))
405
# Dereferences parent symlinks
407
baz_path = osutils.pathjoin(bar_path, 'baz')
408
self.assertEqual(baz_path, osutils.dereference_path('./foo/baz'))
410
# Dereferences parent symlinks that are the first path element
411
self.assertEqual(baz_path, osutils.dereference_path('foo/baz'))
413
# Dereferences parent symlinks in absolute paths
414
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
415
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
417
def test_changing_access(self):
418
f = file('file', 'w')
422
# Make a file readonly
423
osutils.make_readonly('file')
424
mode = os.lstat('file').st_mode
425
self.assertEqual(mode, mode & 0777555)
427
# Make a file writable
428
osutils.make_writable('file')
429
mode = os.lstat('file').st_mode
430
self.assertEqual(mode, mode | 0200)
432
if osutils.has_symlinks():
433
# should not error when handed a symlink
434
os.symlink('nonexistent', 'dangling')
435
osutils.make_readonly('dangling')
436
osutils.make_writable('dangling')
438
def test_host_os_dereferences_symlinks(self):
439
osutils.host_os_dereferences_symlinks()
442
class TestCanonicalRelPath(tests.TestCaseInTempDir):
444
_test_needs_features = [tests.CaseInsCasePresFilenameFeature]
446
def test_canonical_relpath_simple(self):
447
f = file('MixedCaseName', 'w')
449
# Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
450
real_base_dir = osutils.realpath(self.test_base_dir)
451
actual = osutils.canonical_relpath(real_base_dir, 'mixedcasename')
452
self.failUnlessEqual('work/MixedCaseName', actual)
454
def test_canonical_relpath_missing_tail(self):
455
os.mkdir('MixedCaseParent')
456
# Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
457
real_base_dir = osutils.realpath(self.test_base_dir)
458
actual = osutils.canonical_relpath(real_base_dir,
459
'mixedcaseparent/nochild')
460
self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
463
class TestPumpFile(tests.TestCase):
464
"""Test pumpfile method."""
467
tests.TestCase.setUp(self)
468
# create a test datablock
469
self.block_size = 512
470
pattern = '0123456789ABCDEF'
471
self.test_data = pattern * (3 * self.block_size / len(pattern))
472
self.test_data_len = len(self.test_data)
474
def test_bracket_block_size(self):
475
"""Read data in blocks with the requested read size bracketing the
477
# make sure test data is larger than max read size
478
self.assertTrue(self.test_data_len > self.block_size)
480
from_file = file_utils.FakeReadFile(self.test_data)
483
# read (max / 2) bytes and verify read size wasn't affected
484
num_bytes_to_read = self.block_size / 2
485
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
486
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
487
self.assertEqual(from_file.get_read_count(), 1)
489
# read (max) bytes and verify read size wasn't affected
490
num_bytes_to_read = self.block_size
491
from_file.reset_read_count()
492
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
493
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
494
self.assertEqual(from_file.get_read_count(), 1)
496
# read (max + 1) bytes and verify read size was limited
497
num_bytes_to_read = self.block_size + 1
498
from_file.reset_read_count()
499
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
500
self.assertEqual(from_file.get_max_read_size(), self.block_size)
501
self.assertEqual(from_file.get_read_count(), 2)
503
# finish reading the rest of the data
504
num_bytes_to_read = self.test_data_len - to_file.tell()
505
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
507
# report error if the data wasn't equal (we only report the size due
508
# to the length of the data)
509
response_data = to_file.getvalue()
510
if response_data != self.test_data:
511
message = "Data not equal. Expected %d bytes, received %d."
512
self.fail(message % (len(response_data), self.test_data_len))
514
def test_specified_size(self):
515
"""Request a transfer larger than the maximum block size and verify
516
that the maximum read doesn't exceed the block_size."""
517
# make sure test data is larger than max read size
518
self.assertTrue(self.test_data_len > self.block_size)
520
# retrieve data in blocks
521
from_file = file_utils.FakeReadFile(self.test_data)
523
osutils.pumpfile(from_file, to_file, self.test_data_len,
526
# verify read size was equal to the maximum read size
527
self.assertTrue(from_file.get_max_read_size() > 0)
528
self.assertEqual(from_file.get_max_read_size(), self.block_size)
529
self.assertEqual(from_file.get_read_count(), 3)
531
# report error if the data wasn't equal (we only report the size due
532
# to the length of the data)
533
response_data = to_file.getvalue()
534
if response_data != self.test_data:
535
message = "Data not equal. Expected %d bytes, received %d."
536
self.fail(message % (len(response_data), self.test_data_len))
538
def test_to_eof(self):
539
"""Read to end-of-file and verify that the reads are not larger than
540
the maximum read size."""
541
# make sure test data is larger than max read size
542
self.assertTrue(self.test_data_len > self.block_size)
544
# retrieve data to EOF
545
from_file = file_utils.FakeReadFile(self.test_data)
547
osutils.pumpfile(from_file, to_file, -1, self.block_size)
549
# verify read size was equal to the maximum read size
550
self.assertEqual(from_file.get_max_read_size(), self.block_size)
551
self.assertEqual(from_file.get_read_count(), 4)
553
# report error if the data wasn't equal (we only report the size due
554
# to the length of the data)
555
response_data = to_file.getvalue()
556
if response_data != self.test_data:
557
message = "Data not equal. Expected %d bytes, received %d."
558
self.fail(message % (len(response_data), self.test_data_len))
560
def test_defaults(self):
561
"""Verifies that the default arguments will read to EOF -- this
562
test verifies that any existing usages of pumpfile will not be broken
563
with this new version."""
564
# retrieve data using default (old) pumpfile method
565
from_file = file_utils.FakeReadFile(self.test_data)
567
osutils.pumpfile(from_file, to_file)
569
# report error if the data wasn't equal (we only report the size due
570
# to the length of the data)
571
response_data = to_file.getvalue()
572
if response_data != self.test_data:
573
message = "Data not equal. Expected %d bytes, received %d."
574
self.fail(message % (len(response_data), self.test_data_len))
576
def test_report_activity(self):
578
def log_activity(length, direction):
579
activity.append((length, direction))
580
from_file = StringIO(self.test_data)
582
osutils.pumpfile(from_file, to_file, buff_size=500,
583
report_activity=log_activity, direction='read')
584
self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
585
(36, 'read')], activity)
587
from_file = StringIO(self.test_data)
590
osutils.pumpfile(from_file, to_file, buff_size=500,
591
report_activity=log_activity, direction='write')
592
self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
593
(36, 'write')], activity)
595
# And with a limited amount of data
596
from_file = StringIO(self.test_data)
599
osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
600
report_activity=log_activity, direction='read')
601
self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
605
class TestPumpStringFile(tests.TestCase):
607
def test_empty(self):
609
osutils.pump_string_file("", output)
610
self.assertEqual("", output.getvalue())
612
def test_more_than_segment_size(self):
614
osutils.pump_string_file("123456789", output, 2)
615
self.assertEqual("123456789", output.getvalue())
617
def test_segment_size(self):
619
osutils.pump_string_file("12", output, 2)
620
self.assertEqual("12", output.getvalue())
622
def test_segment_size_multiple(self):
624
osutils.pump_string_file("1234", output, 2)
625
self.assertEqual("1234", output.getvalue())
628
class TestSafeUnicode(tests.TestCase):
630
def test_from_ascii_string(self):
631
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
633
def test_from_unicode_string_ascii_contents(self):
634
self.assertEqual(u'bargam', osutils.safe_unicode(u'bargam'))
636
def test_from_unicode_string_unicode_contents(self):
637
self.assertEqual(u'bargam\xae', osutils.safe_unicode(u'bargam\xae'))
639
def test_from_utf8_string(self):
640
self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
642
def test_bad_utf8_string(self):
643
self.assertRaises(errors.BzrBadParameterNotUnicode,
644
osutils.safe_unicode,
648
class TestSafeUtf8(tests.TestCase):
650
def test_from_ascii_string(self):
652
self.assertEqual('foobar', osutils.safe_utf8(f))
654
def test_from_unicode_string_ascii_contents(self):
655
self.assertEqual('bargam', osutils.safe_utf8(u'bargam'))
657
def test_from_unicode_string_unicode_contents(self):
658
self.assertEqual('bargam\xc2\xae', osutils.safe_utf8(u'bargam\xae'))
660
def test_from_utf8_string(self):
661
self.assertEqual('foo\xc2\xae', osutils.safe_utf8('foo\xc2\xae'))
663
def test_bad_utf8_string(self):
664
self.assertRaises(errors.BzrBadParameterNotUnicode,
665
osutils.safe_utf8, '\xbb\xbb')
668
class TestSafeRevisionId(tests.TestCase):
670
def test_from_ascii_string(self):
671
# this shouldn't give a warning because it's getting an ascii string
672
self.assertEqual('foobar', osutils.safe_revision_id('foobar'))
674
def test_from_unicode_string_ascii_contents(self):
675
self.assertEqual('bargam',
676
osutils.safe_revision_id(u'bargam', warn=False))
678
def test_from_unicode_deprecated(self):
679
self.assertEqual('bargam',
680
self.callDeprecated([osutils._revision_id_warning],
681
osutils.safe_revision_id, u'bargam'))
683
def test_from_unicode_string_unicode_contents(self):
684
self.assertEqual('bargam\xc2\xae',
685
osutils.safe_revision_id(u'bargam\xae', warn=False))
687
def test_from_utf8_string(self):
688
self.assertEqual('foo\xc2\xae',
689
osutils.safe_revision_id('foo\xc2\xae'))
692
"""Currently, None is a valid revision_id"""
693
self.assertEqual(None, osutils.safe_revision_id(None))
696
class TestSafeFileId(tests.TestCase):
698
def test_from_ascii_string(self):
699
self.assertEqual('foobar', osutils.safe_file_id('foobar'))
701
def test_from_unicode_string_ascii_contents(self):
702
self.assertEqual('bargam', osutils.safe_file_id(u'bargam', warn=False))
704
def test_from_unicode_deprecated(self):
705
self.assertEqual('bargam',
706
self.callDeprecated([osutils._file_id_warning],
707
osutils.safe_file_id, u'bargam'))
709
def test_from_unicode_string_unicode_contents(self):
710
self.assertEqual('bargam\xc2\xae',
711
osutils.safe_file_id(u'bargam\xae', warn=False))
713
def test_from_utf8_string(self):
714
self.assertEqual('foo\xc2\xae',
715
osutils.safe_file_id('foo\xc2\xae'))
718
"""Currently, None is a valid revision_id"""
719
self.assertEqual(None, osutils.safe_file_id(None))
722
class TestWin32Funcs(tests.TestCase):
723
"""Test that _win32 versions of os utilities return appropriate paths."""
725
def test_abspath(self):
726
self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
727
self.assertEqual('C:/foo', osutils._win32_abspath('C:/foo'))
728
self.assertEqual('//HOST/path', osutils._win32_abspath(r'\\HOST\path'))
729
self.assertEqual('//HOST/path', osutils._win32_abspath('//HOST/path'))
731
def test_realpath(self):
732
self.assertEqual('C:/foo', osutils._win32_realpath('C:\\foo'))
733
self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
735
def test_pathjoin(self):
736
self.assertEqual('path/to/foo',
737
osutils._win32_pathjoin('path', 'to', 'foo'))
738
self.assertEqual('C:/foo',
739
osutils._win32_pathjoin('path\\to', 'C:\\foo'))
740
self.assertEqual('C:/foo',
741
osutils._win32_pathjoin('path/to', 'C:/foo'))
742
self.assertEqual('path/to/foo',
743
osutils._win32_pathjoin('path/to/', 'foo'))
744
self.assertEqual('/foo',
745
osutils._win32_pathjoin('C:/path/to/', '/foo'))
746
self.assertEqual('/foo',
747
osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
749
def test_normpath(self):
750
self.assertEqual('path/to/foo',
751
osutils._win32_normpath(r'path\\from\..\to\.\foo'))
752
self.assertEqual('path/to/foo',
753
osutils._win32_normpath('path//from/../to/./foo'))
755
def test_getcwd(self):
756
cwd = osutils._win32_getcwd()
757
os_cwd = os.getcwdu()
758
self.assertEqual(os_cwd[1:].replace('\\', '/'), cwd[1:])
759
# win32 is inconsistent whether it returns lower or upper case
760
# and even if it was consistent the user might type the other
761
# so we force it to uppercase
762
# running python.exe under cmd.exe return capital C:\\
763
# running win32 python inside a cygwin shell returns lowercase
764
self.assertEqual(os_cwd[0].upper(), cwd[0])
766
def test_fixdrive(self):
767
self.assertEqual('H:/foo', osutils._win32_fixdrive('h:/foo'))
768
self.assertEqual('H:/foo', osutils._win32_fixdrive('H:/foo'))
769
self.assertEqual('C:\\foo', osutils._win32_fixdrive('c:\\foo'))
771
def test_win98_abspath(self):
773
self.assertEqual('C:/foo', osutils._win98_abspath('C:\\foo'))
774
self.assertEqual('C:/foo', osutils._win98_abspath('C:/foo'))
776
self.assertEqual('//HOST/path', osutils._win98_abspath(r'\\HOST\path'))
777
self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
779
cwd = osutils.getcwd().rstrip('/')
780
drive = osutils._nt_splitdrive(cwd)[0]
781
self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
782
self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
785
self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
788
class TestWin32FuncsDirs(tests.TestCaseInTempDir):
789
"""Test win32 functions that create files."""
791
def test_getcwd(self):
792
self.requireFeature(tests.UnicodeFilenameFeature)
795
# TODO: jam 20060427 This will probably fail on Mac OSX because
796
# it will change the normalization of B\xe5gfors
797
# Consider using a different unicode character, or make
798
# osutils.getcwd() renormalize the path.
799
self.assertEndsWith(osutils._win32_getcwd(), u'mu-\xb5')
801
def test_minimum_path_selection(self):
802
self.assertEqual(set(),
803
osutils.minimum_path_selection([]))
804
self.assertEqual(set(['a']),
805
osutils.minimum_path_selection(['a']))
806
self.assertEqual(set(['a', 'b']),
807
osutils.minimum_path_selection(['a', 'b']))
808
self.assertEqual(set(['a/', 'b']),
809
osutils.minimum_path_selection(['a/', 'b']))
810
self.assertEqual(set(['a/', 'b']),
811
osutils.minimum_path_selection(['a/c', 'a/', 'b']))
812
self.assertEqual(set(['a-b', 'a', 'a0b']),
813
osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
815
def test_mkdtemp(self):
816
tmpdir = osutils._win32_mkdtemp(dir='.')
817
self.assertFalse('\\' in tmpdir)
819
def test_rename(self):
827
osutils._win32_rename('b', 'a')
828
self.failUnlessExists('a')
829
self.failIfExists('b')
830
self.assertFileEqual('baz\n', 'a')
832
def test_rename_missing_file(self):
838
osutils._win32_rename('b', 'a')
839
except (IOError, OSError), e:
840
self.assertEqual(errno.ENOENT, e.errno)
841
self.assertFileEqual('foo\n', 'a')
843
def test_rename_missing_dir(self):
846
osutils._win32_rename('b', 'a')
847
except (IOError, OSError), e:
848
self.assertEqual(errno.ENOENT, e.errno)
850
def test_rename_current_dir(self):
853
# You can't rename the working directory
854
# doing rename non-existant . usually
855
# just raises ENOENT, since non-existant
858
osutils._win32_rename('b', '.')
859
except (IOError, OSError), e:
860
self.assertEqual(errno.ENOENT, e.errno)
862
def test_splitpath(self):
863
def check(expected, path):
864
self.assertEqual(expected, osutils.splitpath(path))
867
check(['a', 'b'], 'a/b')
868
check(['a', 'b'], 'a/./b')
869
check(['a', '.b'], 'a/.b')
870
check(['a', '.b'], 'a\\.b')
872
self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
875
class TestParentDirectories(tests.TestCaseInTempDir):
876
"""Test osutils.parent_directories()"""
878
def test_parent_directories(self):
879
self.assertEqual([], osutils.parent_directories('a'))
880
self.assertEqual(['a'], osutils.parent_directories('a/b'))
881
self.assertEqual(['a/b', 'a'], osutils.parent_directories('a/b/c'))
884
class TestMacFuncsDirs(tests.TestCaseInTempDir):
885
"""Test mac special functions that require directories."""
887
def test_getcwd(self):
888
self.requireFeature(tests.UnicodeFilenameFeature)
889
os.mkdir(u'B\xe5gfors')
890
os.chdir(u'B\xe5gfors')
891
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
893
def test_getcwd_nonnorm(self):
894
self.requireFeature(tests.UnicodeFilenameFeature)
895
# Test that _mac_getcwd() will normalize this path
896
os.mkdir(u'Ba\u030agfors')
897
os.chdir(u'Ba\u030agfors')
898
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
901
class TestChunksToLines(tests.TestCase):
903
def test_smoketest(self):
904
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
905
osutils.chunks_to_lines(['foo\nbar', '\nbaz\n']))
906
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
907
osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
909
def test_osutils_binding(self):
910
from bzrlib.tests import test__chunks_to_lines
911
if test__chunks_to_lines.CompiledChunksToLinesFeature.available():
912
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
914
from bzrlib._chunks_to_lines_py import chunks_to_lines
915
self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
918
class TestSplitLines(tests.TestCase):
920
def test_split_unicode(self):
921
self.assertEqual([u'foo\n', u'bar\xae'],
922
osutils.split_lines(u'foo\nbar\xae'))
923
self.assertEqual([u'foo\n', u'bar\xae\n'],
924
osutils.split_lines(u'foo\nbar\xae\n'))
926
def test_split_with_carriage_returns(self):
927
self.assertEqual(['foo\rbar\n'],
928
osutils.split_lines('foo\rbar\n'))
931
class TestWalkDirs(tests.TestCaseInTempDir):
933
def assertExpectedBlocks(self, expected, result):
934
self.assertEqual(expected,
935
[(dirinfo, [line[0:3] for line in block])
936
for dirinfo, block in result])
938
def test_walkdirs(self):
947
self.build_tree(tree)
948
expected_dirblocks = [
950
[('0file', '0file', 'file'),
951
('1dir', '1dir', 'directory'),
952
('2file', '2file', 'file'),
956
[('1dir/0file', '0file', 'file'),
957
('1dir/1dir', '1dir', 'directory'),
960
(('1dir/1dir', './1dir/1dir'),
967
for dirdetail, dirblock in osutils.walkdirs('.'):
968
if len(dirblock) and dirblock[0][1] == '.bzr':
969
# this tests the filtering of selected paths
972
result.append((dirdetail, dirblock))
974
self.assertTrue(found_bzrdir)
975
self.assertExpectedBlocks(expected_dirblocks, result)
976
# you can search a subdir only, with a supplied prefix.
978
for dirblock in osutils.walkdirs('./1dir', '1dir'):
979
result.append(dirblock)
980
self.assertExpectedBlocks(expected_dirblocks[1:], result)
982
def test_walkdirs_os_error(self):
983
# <https://bugs.edge.launchpad.net/bzr/+bug/338653>
984
# Pyrex readdir didn't raise useful messages if it had an error
985
# reading the directory
986
if sys.platform == 'win32':
987
raise tests.TestNotApplicable(
988
"readdir IOError not tested on win32")
989
os.mkdir("test-unreadable")
990
os.chmod("test-unreadable", 0000)
991
# must chmod it back so that it can be removed
992
self.addCleanup(os.chmod, "test-unreadable", 0700)
993
# The error is not raised until the generator is actually evaluated.
994
# (It would be ok if it happened earlier but at the moment it
996
e = self.assertRaises(OSError, list, osutils._walkdirs_utf8("."))
997
self.assertEquals('./test-unreadable', e.filename)
998
self.assertEquals(errno.EACCES, e.errno)
999
# Ensure the message contains the file name
1000
self.assertContainsRe(str(e), "\./test-unreadable")
1002
def test__walkdirs_utf8(self):
1011
self.build_tree(tree)
1012
expected_dirblocks = [
1014
[('0file', '0file', 'file'),
1015
('1dir', '1dir', 'directory'),
1016
('2file', '2file', 'file'),
1019
(('1dir', './1dir'),
1020
[('1dir/0file', '0file', 'file'),
1021
('1dir/1dir', '1dir', 'directory'),
1024
(('1dir/1dir', './1dir/1dir'),
1030
found_bzrdir = False
1031
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1032
if len(dirblock) and dirblock[0][1] == '.bzr':
1033
# this tests the filtering of selected paths
1036
result.append((dirdetail, dirblock))
1038
self.assertTrue(found_bzrdir)
1039
self.assertExpectedBlocks(expected_dirblocks, result)
1041
# you can search a subdir only, with a supplied prefix.
1043
for dirblock in osutils.walkdirs('./1dir', '1dir'):
1044
result.append(dirblock)
1045
self.assertExpectedBlocks(expected_dirblocks[1:], result)
1047
def _filter_out_stat(self, result):
1048
"""Filter out the stat value from the walkdirs result"""
1049
for dirdetail, dirblock in result:
1051
for info in dirblock:
1052
# Ignore info[3] which is the stat
1053
new_dirblock.append((info[0], info[1], info[2], info[4]))
1054
dirblock[:] = new_dirblock
1056
def _save_platform_info(self):
1057
cur_winver = win32utils.winver
1058
cur_fs_enc = osutils._fs_enc
1059
cur_dir_reader = osutils._selected_dir_reader
1061
win32utils.winver = cur_winver
1062
osutils._fs_enc = cur_fs_enc
1063
osutils._selected_dir_reader = cur_dir_reader
1064
self.addCleanup(restore)
1066
def assertDirReaderIs(self, expected):
1067
"""Assert the right implementation for _walkdirs_utf8 is chosen."""
1068
# Force it to redetect
1069
osutils._selected_dir_reader = None
1070
# Nothing to list, but should still trigger the selection logic
1071
self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
1072
self.assertIsInstance(osutils._selected_dir_reader, expected)
1074
def test_force_walkdirs_utf8_fs_utf8(self):
1075
self.requireFeature(UTF8DirReaderFeature)
1076
self._save_platform_info()
1077
win32utils.winver = None # Avoid the win32 detection code
1078
osutils._fs_enc = 'UTF-8'
1079
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1081
def test_force_walkdirs_utf8_fs_ascii(self):
1082
self.requireFeature(UTF8DirReaderFeature)
1083
self._save_platform_info()
1084
win32utils.winver = None # Avoid the win32 detection code
1085
osutils._fs_enc = 'US-ASCII'
1086
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1088
def test_force_walkdirs_utf8_fs_ANSI(self):
1089
self.requireFeature(UTF8DirReaderFeature)
1090
self._save_platform_info()
1091
win32utils.winver = None # Avoid the win32 detection code
1092
osutils._fs_enc = 'ANSI_X3.4-1968'
1093
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1095
def test_force_walkdirs_utf8_fs_latin1(self):
1096
self._save_platform_info()
1097
win32utils.winver = None # Avoid the win32 detection code
1098
osutils._fs_enc = 'latin1'
1099
self.assertDirReaderIs(osutils.UnicodeDirReader)
1101
def test_force_walkdirs_utf8_nt(self):
1102
# Disabled because the thunk of the whole walkdirs api is disabled.
1103
self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1104
self._save_platform_info()
1105
win32utils.winver = 'Windows NT'
1106
from bzrlib._walkdirs_win32 import Win32ReadDir
1107
self.assertDirReaderIs(Win32ReadDir)
1109
def test_force_walkdirs_utf8_98(self):
1110
self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1111
self._save_platform_info()
1112
win32utils.winver = 'Windows 98'
1113
self.assertDirReaderIs(osutils.UnicodeDirReader)
1115
def test_unicode_walkdirs(self):
1116
"""Walkdirs should always return unicode paths."""
1117
self.requireFeature(tests.UnicodeFilenameFeature)
1118
name0 = u'0file-\xb6'
1119
name1 = u'1dir-\u062c\u0648'
1120
name2 = u'2file-\u0633'
1124
name1 + '/' + name0,
1125
name1 + '/' + name1 + '/',
1128
self.build_tree(tree)
1129
expected_dirblocks = [
1131
[(name0, name0, 'file', './' + name0),
1132
(name1, name1, 'directory', './' + name1),
1133
(name2, name2, 'file', './' + name2),
1136
((name1, './' + name1),
1137
[(name1 + '/' + name0, name0, 'file', './' + name1
1139
(name1 + '/' + name1, name1, 'directory', './' + name1
1143
((name1 + '/' + name1, './' + name1 + '/' + name1),
1148
result = list(osutils.walkdirs('.'))
1149
self._filter_out_stat(result)
1150
self.assertEqual(expected_dirblocks, result)
1151
result = list(osutils.walkdirs(u'./'+name1, name1))
1152
self._filter_out_stat(result)
1153
self.assertEqual(expected_dirblocks[1:], result)
1155
def test_unicode__walkdirs_utf8(self):
1156
"""Walkdirs_utf8 should always return utf8 paths.
1158
The abspath portion might be in unicode or utf-8
1160
self.requireFeature(tests.UnicodeFilenameFeature)
1161
name0 = u'0file-\xb6'
1162
name1 = u'1dir-\u062c\u0648'
1163
name2 = u'2file-\u0633'
1167
name1 + '/' + name0,
1168
name1 + '/' + name1 + '/',
1171
self.build_tree(tree)
1172
name0 = name0.encode('utf8')
1173
name1 = name1.encode('utf8')
1174
name2 = name2.encode('utf8')
1176
expected_dirblocks = [
1178
[(name0, name0, 'file', './' + name0),
1179
(name1, name1, 'directory', './' + name1),
1180
(name2, name2, 'file', './' + name2),
1183
((name1, './' + name1),
1184
[(name1 + '/' + name0, name0, 'file', './' + name1
1186
(name1 + '/' + name1, name1, 'directory', './' + name1
1190
((name1 + '/' + name1, './' + name1 + '/' + name1),
1196
# For ease in testing, if walkdirs_utf8 returns Unicode, assert that
1197
# all abspaths are Unicode, and encode them back into utf8.
1198
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1199
self.assertIsInstance(dirdetail[0], str)
1200
if isinstance(dirdetail[1], unicode):
1201
dirdetail = (dirdetail[0], dirdetail[1].encode('utf8'))
1202
dirblock = [list(info) for info in dirblock]
1203
for info in dirblock:
1204
self.assertIsInstance(info[4], unicode)
1205
info[4] = info[4].encode('utf8')
1207
for info in dirblock:
1208
self.assertIsInstance(info[0], str)
1209
self.assertIsInstance(info[1], str)
1210
self.assertIsInstance(info[4], str)
1211
# Remove the stat information
1212
new_dirblock.append((info[0], info[1], info[2], info[4]))
1213
result.append((dirdetail, new_dirblock))
1214
self.assertEqual(expected_dirblocks, result)
1216
def test__walkdirs_utf8_with_unicode_fs(self):
1217
"""UnicodeDirReader should be a safe fallback everywhere
1219
The abspath portion should be in unicode
1221
self.requireFeature(tests.UnicodeFilenameFeature)
1222
# Use the unicode reader. TODO: split into driver-and-driven unit
1224
self._save_platform_info()
1225
osutils._selected_dir_reader = osutils.UnicodeDirReader()
1226
name0u = u'0file-\xb6'
1227
name1u = u'1dir-\u062c\u0648'
1228
name2u = u'2file-\u0633'
1232
name1u + '/' + name0u,
1233
name1u + '/' + name1u + '/',
1236
self.build_tree(tree)
1237
name0 = name0u.encode('utf8')
1238
name1 = name1u.encode('utf8')
1239
name2 = name2u.encode('utf8')
1241
# All of the abspaths should be in unicode, all of the relative paths
1243
expected_dirblocks = [
1245
[(name0, name0, 'file', './' + name0u),
1246
(name1, name1, 'directory', './' + name1u),
1247
(name2, name2, 'file', './' + name2u),
1250
((name1, './' + name1u),
1251
[(name1 + '/' + name0, name0, 'file', './' + name1u
1253
(name1 + '/' + name1, name1, 'directory', './' + name1u
1257
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1262
result = list(osutils._walkdirs_utf8('.'))
1263
self._filter_out_stat(result)
1264
self.assertEqual(expected_dirblocks, result)
1266
def test__walkdirs_utf8_win32readdir(self):
1267
self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1268
self.requireFeature(tests.UnicodeFilenameFeature)
1269
from bzrlib._walkdirs_win32 import Win32ReadDir
1270
self._save_platform_info()
1271
osutils._selected_dir_reader = Win32ReadDir()
1272
name0u = u'0file-\xb6'
1273
name1u = u'1dir-\u062c\u0648'
1274
name2u = u'2file-\u0633'
1278
name1u + '/' + name0u,
1279
name1u + '/' + name1u + '/',
1282
self.build_tree(tree)
1283
name0 = name0u.encode('utf8')
1284
name1 = name1u.encode('utf8')
1285
name2 = name2u.encode('utf8')
1287
# All of the abspaths should be in unicode, all of the relative paths
1289
expected_dirblocks = [
1291
[(name0, name0, 'file', './' + name0u),
1292
(name1, name1, 'directory', './' + name1u),
1293
(name2, name2, 'file', './' + name2u),
1296
((name1, './' + name1u),
1297
[(name1 + '/' + name0, name0, 'file', './' + name1u
1299
(name1 + '/' + name1, name1, 'directory', './' + name1u
1303
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1308
result = list(osutils._walkdirs_utf8(u'.'))
1309
self._filter_out_stat(result)
1310
self.assertEqual(expected_dirblocks, result)
1312
def assertStatIsCorrect(self, path, win32stat):
1313
os_stat = os.stat(path)
1314
self.assertEqual(os_stat.st_size, win32stat.st_size)
1315
self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
1316
self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
1317
self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
1318
self.assertEqual(os_stat.st_dev, win32stat.st_dev)
1319
self.assertEqual(os_stat.st_ino, win32stat.st_ino)
1320
self.assertEqual(os_stat.st_mode, win32stat.st_mode)
1322
def test__walkdirs_utf_win32_find_file_stat_file(self):
1323
"""make sure our Stat values are valid"""
1324
self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1325
self.requireFeature(tests.UnicodeFilenameFeature)
1326
from bzrlib._walkdirs_win32 import Win32ReadDir
1327
name0u = u'0file-\xb6'
1328
name0 = name0u.encode('utf8')
1329
self.build_tree([name0u])
1330
# I hate to sleep() here, but I'm trying to make the ctime different
1333
f = open(name0u, 'ab')
1335
f.write('just a small update')
1339
result = Win32ReadDir().read_dir('', u'.')
1341
self.assertEqual((name0, name0, 'file'), entry[:3])
1342
self.assertEqual(u'./' + name0u, entry[4])
1343
self.assertStatIsCorrect(entry[4], entry[3])
1344
self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
1346
def test__walkdirs_utf_win32_find_file_stat_directory(self):
1347
"""make sure our Stat values are valid"""
1348
self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1349
self.requireFeature(tests.UnicodeFilenameFeature)
1350
from bzrlib._walkdirs_win32 import Win32ReadDir
1351
name0u = u'0dir-\u062c\u0648'
1352
name0 = name0u.encode('utf8')
1353
self.build_tree([name0u + '/'])
1355
result = Win32ReadDir().read_dir('', u'.')
1357
self.assertEqual((name0, name0, 'directory'), entry[:3])
1358
self.assertEqual(u'./' + name0u, entry[4])
1359
self.assertStatIsCorrect(entry[4], entry[3])
1361
def assertPathCompare(self, path_less, path_greater):
1362
"""check that path_less and path_greater compare correctly."""
1363
self.assertEqual(0, osutils.compare_paths_prefix_order(
1364
path_less, path_less))
1365
self.assertEqual(0, osutils.compare_paths_prefix_order(
1366
path_greater, path_greater))
1367
self.assertEqual(-1, osutils.compare_paths_prefix_order(
1368
path_less, path_greater))
1369
self.assertEqual(1, osutils.compare_paths_prefix_order(
1370
path_greater, path_less))
1372
def test_compare_paths_prefix_order(self):
1373
# root before all else
1374
self.assertPathCompare("/", "/a")
1375
# alpha within a dir
1376
self.assertPathCompare("/a", "/b")
1377
self.assertPathCompare("/b", "/z")
1378
# high dirs before lower.
1379
self.assertPathCompare("/z", "/a/a")
1380
# except if the deeper dir should be output first
1381
self.assertPathCompare("/a/b/c", "/d/g")
1382
# lexical betwen dirs of the same height
1383
self.assertPathCompare("/a/z", "/z/z")
1384
self.assertPathCompare("/a/c/z", "/a/d/e")
1386
# this should also be consistent for no leading / paths
1387
# root before all else
1388
self.assertPathCompare("", "a")
1389
# alpha within a dir
1390
self.assertPathCompare("a", "b")
1391
self.assertPathCompare("b", "z")
1392
# high dirs before lower.
1393
self.assertPathCompare("z", "a/a")
1394
# except if the deeper dir should be output first
1395
self.assertPathCompare("a/b/c", "d/g")
1396
# lexical betwen dirs of the same height
1397
self.assertPathCompare("a/z", "z/z")
1398
self.assertPathCompare("a/c/z", "a/d/e")
1400
def test_path_prefix_sorting(self):
1401
"""Doing a sort on path prefix should match our sample data."""
1416
dir_sorted_paths = [
1432
sorted(original_paths, key=osutils.path_prefix_key))
1433
# using the comparison routine shoudl work too:
1436
sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
1439
class TestCopyTree(tests.TestCaseInTempDir):
1441
def test_copy_basic_tree(self):
1442
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1443
osutils.copy_tree('source', 'target')
1444
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1445
self.assertEqual(['c'], os.listdir('target/b'))
1447
def test_copy_tree_target_exists(self):
1448
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c',
1450
osutils.copy_tree('source', 'target')
1451
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1452
self.assertEqual(['c'], os.listdir('target/b'))
1454
def test_copy_tree_symlinks(self):
1455
self.requireFeature(tests.SymlinkFeature)
1456
self.build_tree(['source/'])
1457
os.symlink('a/generic/path', 'source/lnk')
1458
osutils.copy_tree('source', 'target')
1459
self.assertEqual(['lnk'], os.listdir('target'))
1460
self.assertEqual('a/generic/path', os.readlink('target/lnk'))
1462
def test_copy_tree_handlers(self):
1463
processed_files = []
1464
processed_links = []
1465
def file_handler(from_path, to_path):
1466
processed_files.append(('f', from_path, to_path))
1467
def dir_handler(from_path, to_path):
1468
processed_files.append(('d', from_path, to_path))
1469
def link_handler(from_path, to_path):
1470
processed_links.append((from_path, to_path))
1471
handlers = {'file':file_handler,
1472
'directory':dir_handler,
1473
'symlink':link_handler,
1476
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1477
if osutils.has_symlinks():
1478
os.symlink('a/generic/path', 'source/lnk')
1479
osutils.copy_tree('source', 'target', handlers=handlers)
1481
self.assertEqual([('d', 'source', 'target'),
1482
('f', 'source/a', 'target/a'),
1483
('d', 'source/b', 'target/b'),
1484
('f', 'source/b/c', 'target/b/c'),
1486
self.failIfExists('target')
1487
if osutils.has_symlinks():
1488
self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1491
class TestSetUnsetEnv(tests.TestCase):
1492
"""Test updating the environment"""
1495
super(TestSetUnsetEnv, self).setUp()
1497
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
1498
'Environment was not cleaned up properly.'
1499
' Variable BZR_TEST_ENV_VAR should not exist.')
1501
if 'BZR_TEST_ENV_VAR' in os.environ:
1502
del os.environ['BZR_TEST_ENV_VAR']
1504
self.addCleanup(cleanup)
1507
"""Test that we can set an env variable"""
1508
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1509
self.assertEqual(None, old)
1510
self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
1512
def test_double_set(self):
1513
"""Test that we get the old value out"""
1514
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1515
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
1516
self.assertEqual('foo', old)
1517
self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
1519
def test_unicode(self):
1520
"""Environment can only contain plain strings
1522
So Unicode strings must be encoded.
1524
uni_val, env_val = tests.probe_unicode_in_user_encoding()
1526
raise tests.TestSkipped(
1527
'Cannot find a unicode character that works in encoding %s'
1528
% (osutils.get_user_encoding(),))
1530
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1531
self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
1533
def test_unset(self):
1534
"""Test that passing None will remove the env var"""
1535
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1536
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1537
self.assertEqual('foo', old)
1538
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1539
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1542
class TestSizeShaFile(tests.TestCaseInTempDir):
1544
def test_sha_empty(self):
1545
self.build_tree_contents([('foo', '')])
1546
expected_sha = osutils.sha_string('')
1548
self.addCleanup(f.close)
1549
size, sha = osutils.size_sha_file(f)
1550
self.assertEqual(0, size)
1551
self.assertEqual(expected_sha, sha)
1553
def test_sha_mixed_endings(self):
1554
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1555
self.build_tree_contents([('foo', text)])
1556
expected_sha = osutils.sha_string(text)
1558
self.addCleanup(f.close)
1559
size, sha = osutils.size_sha_file(f)
1560
self.assertEqual(38, size)
1561
self.assertEqual(expected_sha, sha)
1564
class TestShaFileByName(tests.TestCaseInTempDir):
1566
def test_sha_empty(self):
1567
self.build_tree_contents([('foo', '')])
1568
expected_sha = osutils.sha_string('')
1569
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1571
def test_sha_mixed_endings(self):
1572
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1573
self.build_tree_contents([('foo', text)])
1574
expected_sha = osutils.sha_string(text)
1575
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1578
class TestResourceLoading(tests.TestCaseInTempDir):
1580
def test_resource_string(self):
1581
# test resource in bzrlib
1582
text = osutils.resource_string('bzrlib', 'debug.py')
1583
self.assertContainsRe(text, "debug_flags = set()")
1584
# test resource under bzrlib
1585
text = osutils.resource_string('bzrlib.ui', 'text.py')
1586
self.assertContainsRe(text, "class TextUIFactory")
1587
# test unsupported package
1588
self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1590
# test unknown resource
1591
self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1594
class TestReCompile(tests.TestCase):
1596
def test_re_compile_checked(self):
1597
r = osutils.re_compile_checked(r'A*', re.IGNORECASE)
1598
self.assertTrue(r.match('aaaa'))
1599
self.assertTrue(r.match('aAaA'))
1601
def test_re_compile_checked_error(self):
1602
# like https://bugs.launchpad.net/bzr/+bug/251352
1603
err = self.assertRaises(
1604
errors.BzrCommandError,
1605
osutils.re_compile_checked, '*', re.IGNORECASE, 'test case')
1607
"Invalid regular expression in test case: '*': "
1608
"nothing to repeat",
1612
class TestDirReader(tests.TestCaseInTempDir):
1615
_dir_reader_class = None
1616
_native_to_unicode = None
1619
tests.TestCaseInTempDir.setUp(self)
1621
# Save platform specific info and reset it
1622
cur_dir_reader = osutils._selected_dir_reader
1625
osutils._selected_dir_reader = cur_dir_reader
1626
self.addCleanup(restore)
1628
osutils._selected_dir_reader = self._dir_reader_class()
1630
def _get_ascii_tree(self):
1638
expected_dirblocks = [
1640
[('0file', '0file', 'file'),
1641
('1dir', '1dir', 'directory'),
1642
('2file', '2file', 'file'),
1645
(('1dir', './1dir'),
1646
[('1dir/0file', '0file', 'file'),
1647
('1dir/1dir', '1dir', 'directory'),
1650
(('1dir/1dir', './1dir/1dir'),
1655
return tree, expected_dirblocks
1657
def test_walk_cur_dir(self):
1658
tree, expected_dirblocks = self._get_ascii_tree()
1659
self.build_tree(tree)
1660
result = list(osutils._walkdirs_utf8('.'))
1661
# Filter out stat and abspath
1662
self.assertEqual(expected_dirblocks,
1663
[(dirinfo, [line[0:3] for line in block])
1664
for dirinfo, block in result])
1666
def test_walk_sub_dir(self):
1667
tree, expected_dirblocks = self._get_ascii_tree()
1668
self.build_tree(tree)
1669
# you can search a subdir only, with a supplied prefix.
1670
result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1671
# Filter out stat and abspath
1672
self.assertEqual(expected_dirblocks[1:],
1673
[(dirinfo, [line[0:3] for line in block])
1674
for dirinfo, block in result])
1676
def _get_unicode_tree(self):
1677
name0u = u'0file-\xb6'
1678
name1u = u'1dir-\u062c\u0648'
1679
name2u = u'2file-\u0633'
1683
name1u + '/' + name0u,
1684
name1u + '/' + name1u + '/',
1687
name0 = name0u.encode('UTF-8')
1688
name1 = name1u.encode('UTF-8')
1689
name2 = name2u.encode('UTF-8')
1690
expected_dirblocks = [
1692
[(name0, name0, 'file', './' + name0u),
1693
(name1, name1, 'directory', './' + name1u),
1694
(name2, name2, 'file', './' + name2u),
1697
((name1, './' + name1u),
1698
[(name1 + '/' + name0, name0, 'file', './' + name1u
1700
(name1 + '/' + name1, name1, 'directory', './' + name1u
1704
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1709
return tree, expected_dirblocks
1711
def _filter_out(self, raw_dirblocks):
1712
"""Filter out a walkdirs_utf8 result.
1714
stat field is removed, all native paths are converted to unicode
1716
filtered_dirblocks = []
1717
for dirinfo, block in raw_dirblocks:
1718
dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1721
details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1722
filtered_dirblocks.append((dirinfo, details))
1723
return filtered_dirblocks
1725
def test_walk_unicode_tree(self):
1726
self.requireFeature(tests.UnicodeFilenameFeature)
1727
tree, expected_dirblocks = self._get_unicode_tree()
1728
self.build_tree(tree)
1729
result = list(osutils._walkdirs_utf8('.'))
1730
self.assertEqual(expected_dirblocks, self._filter_out(result))
1732
def test_symlink(self):
1733
self.requireFeature(tests.SymlinkFeature)
1734
self.requireFeature(tests.UnicodeFilenameFeature)
1735
target = u'target\N{Euro Sign}'
1736
link_name = u'l\N{Euro Sign}nk'
1737
os.symlink(target, link_name)
1738
target_utf8 = target.encode('UTF-8')
1739
link_name_utf8 = link_name.encode('UTF-8')
1740
expected_dirblocks = [
1742
[(link_name_utf8, link_name_utf8,
1743
'symlink', './' + link_name),],
1745
result = list(osutils._walkdirs_utf8('.'))
1746
self.assertEqual(expected_dirblocks, self._filter_out(result))
1749
class TestReadLink(tests.TestCaseInTempDir):
1750
"""Exposes os.readlink() problems and the osutils solution.
1752
The only guarantee offered by os.readlink(), starting with 2.6, is that a
1753
unicode string will be returned if a unicode string is passed.
1755
But prior python versions failed to properly encode the passed unicode
1758
_test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
1761
super(tests.TestCaseInTempDir, self).setUp()
1762
self.link = u'l\N{Euro Sign}ink'
1763
self.target = u'targe\N{Euro Sign}t'
1764
os.symlink(self.target, self.link)
1766
def test_os_readlink_link_encoding(self):
1767
if sys.version_info < (2, 6):
1768
self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
1770
self.assertEquals(self.target, os.readlink(self.link))
1772
def test_os_readlink_link_decoding(self):
1773
self.assertEquals(self.target.encode(osutils._fs_enc),
1774
os.readlink(self.link.encode(osutils._fs_enc)))
1777
class TestConcurrency(tests.TestCase):
1779
def test_local_concurrency(self):
1780
concurrency = osutils.local_concurrency()
1781
self.assertIsInstance(concurrency, int)
added
removed
bzrlib/tests/test_osutils.py
