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 TestKind(tests.TestCaseInTempDir):
245
def test_file_kind(self):
246
self.build_tree(['file', 'dir/'])
247
self.assertEquals('file', osutils.file_kind('file'))
248
self.assertEquals('directory', osutils.file_kind('dir/'))
249
if osutils.has_symlinks():
250
os.symlink('symlink', 'symlink')
251
self.assertEquals('symlink', osutils.file_kind('symlink'))
253
# TODO: jam 20060529 Test a block device
255
os.lstat('/dev/null')
257
if e.errno not in (errno.ENOENT,):
260
self.assertEquals('chardev', osutils.file_kind('/dev/null'))
262
mkfifo = getattr(os, 'mkfifo', None)
266
self.assertEquals('fifo', osutils.file_kind('fifo'))
270
AF_UNIX = getattr(socket, 'AF_UNIX', None)
272
s = socket.socket(AF_UNIX)
275
self.assertEquals('socket', osutils.file_kind('socket'))
279
def test_kind_marker(self):
280
self.assertEqual("", osutils.kind_marker("file"))
281
self.assertEqual("/", osutils.kind_marker('directory'))
282
self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
283
self.assertEqual("@", osutils.kind_marker("symlink"))
284
self.assertEqual("+", osutils.kind_marker("tree-reference"))
285
self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
288
class TestUmask(tests.TestCaseInTempDir):
290
def test_get_umask(self):
291
if sys.platform == 'win32':
292
# umask always returns '0', no way to set it
293
self.assertEqual(0, osutils.get_umask())
296
orig_umask = osutils.get_umask()
297
self.addCleanup(os.umask, orig_umask)
299
self.assertEqual(0222, osutils.get_umask())
301
self.assertEqual(0022, osutils.get_umask())
303
self.assertEqual(0002, osutils.get_umask())
305
self.assertEqual(0027, osutils.get_umask())
308
class TestDateTime(tests.TestCase):
310
def assertFormatedDelta(self, expected, seconds):
311
"""Assert osutils.format_delta formats as expected"""
312
actual = osutils.format_delta(seconds)
313
self.assertEqual(expected, actual)
315
def test_format_delta(self):
316
self.assertFormatedDelta('0 seconds ago', 0)
317
self.assertFormatedDelta('1 second ago', 1)
318
self.assertFormatedDelta('10 seconds ago', 10)
319
self.assertFormatedDelta('59 seconds ago', 59)
320
self.assertFormatedDelta('89 seconds ago', 89)
321
self.assertFormatedDelta('1 minute, 30 seconds ago', 90)
322
self.assertFormatedDelta('3 minutes, 0 seconds ago', 180)
323
self.assertFormatedDelta('3 minutes, 1 second ago', 181)
324
self.assertFormatedDelta('10 minutes, 15 seconds ago', 615)
325
self.assertFormatedDelta('30 minutes, 59 seconds ago', 1859)
326
self.assertFormatedDelta('31 minutes, 0 seconds ago', 1860)
327
self.assertFormatedDelta('60 minutes, 0 seconds ago', 3600)
328
self.assertFormatedDelta('89 minutes, 59 seconds ago', 5399)
329
self.assertFormatedDelta('1 hour, 30 minutes ago', 5400)
330
self.assertFormatedDelta('2 hours, 30 minutes ago', 9017)
331
self.assertFormatedDelta('10 hours, 0 minutes ago', 36000)
332
self.assertFormatedDelta('24 hours, 0 minutes ago', 86400)
333
self.assertFormatedDelta('35 hours, 59 minutes ago', 129599)
334
self.assertFormatedDelta('36 hours, 0 minutes ago', 129600)
335
self.assertFormatedDelta('36 hours, 0 minutes ago', 129601)
336
self.assertFormatedDelta('36 hours, 1 minute ago', 129660)
337
self.assertFormatedDelta('36 hours, 1 minute ago', 129661)
338
self.assertFormatedDelta('84 hours, 10 minutes ago', 303002)
340
# We handle when time steps the wrong direction because computers
341
# don't have synchronized clocks.
342
self.assertFormatedDelta('84 hours, 10 minutes in the future', -303002)
343
self.assertFormatedDelta('1 second in the future', -1)
344
self.assertFormatedDelta('2 seconds in the future', -2)
346
def test_format_date(self):
347
self.assertRaises(errors.UnsupportedTimezoneFormat,
348
osutils.format_date, 0, timezone='foo')
349
self.assertIsInstance(osutils.format_date(0), str)
350
self.assertIsInstance(osutils.format_local_date(0), unicode)
351
# Testing for the actual value of the local weekday without
352
# duplicating the code from format_date is difficult.
353
# Instead blackbox.test_locale should check for localized
354
# dates once they do occur in output strings.
356
def test_local_time_offset(self):
357
"""Test that local_time_offset() returns a sane value."""
358
offset = osutils.local_time_offset()
359
self.assertTrue(isinstance(offset, int))
360
# Test that the offset is no more than a eighteen hours in
362
# Time zone handling is system specific, so it is difficult to
363
# do more specific tests, but a value outside of this range is
365
eighteen_hours = 18 * 3600
366
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
368
def test_local_time_offset_with_timestamp(self):
369
"""Test that local_time_offset() works with a timestamp."""
370
offset = osutils.local_time_offset(1000000000.1234567)
371
self.assertTrue(isinstance(offset, int))
372
eighteen_hours = 18 * 3600
373
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
376
class TestLinks(tests.TestCaseInTempDir):
378
def test_dereference_path(self):
379
self.requireFeature(tests.SymlinkFeature)
380
cwd = osutils.realpath('.')
382
bar_path = osutils.pathjoin(cwd, 'bar')
383
# Using './' to avoid bug #1213894 (first path component not
384
# dereferenced) in Python 2.4.1 and earlier
385
self.assertEqual(bar_path, osutils.realpath('./bar'))
386
os.symlink('bar', 'foo')
387
self.assertEqual(bar_path, osutils.realpath('./foo'))
389
# Does not dereference terminal symlinks
390
foo_path = osutils.pathjoin(cwd, 'foo')
391
self.assertEqual(foo_path, osutils.dereference_path('./foo'))
393
# Dereferences parent symlinks
395
baz_path = osutils.pathjoin(bar_path, 'baz')
396
self.assertEqual(baz_path, osutils.dereference_path('./foo/baz'))
398
# Dereferences parent symlinks that are the first path element
399
self.assertEqual(baz_path, osutils.dereference_path('foo/baz'))
401
# Dereferences parent symlinks in absolute paths
402
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
403
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
405
def test_changing_access(self):
406
f = file('file', 'w')
410
# Make a file readonly
411
osutils.make_readonly('file')
412
mode = os.lstat('file').st_mode
413
self.assertEqual(mode, mode & 0777555)
415
# Make a file writable
416
osutils.make_writable('file')
417
mode = os.lstat('file').st_mode
418
self.assertEqual(mode, mode | 0200)
420
if osutils.has_symlinks():
421
# should not error when handed a symlink
422
os.symlink('nonexistent', 'dangling')
423
osutils.make_readonly('dangling')
424
osutils.make_writable('dangling')
426
def test_host_os_dereferences_symlinks(self):
427
osutils.host_os_dereferences_symlinks()
430
class TestCanonicalRelPath(tests.TestCaseInTempDir):
432
_test_needs_features = [tests.CaseInsCasePresFilenameFeature]
434
def test_canonical_relpath_simple(self):
435
f = file('MixedCaseName', 'w')
437
# Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
438
real_base_dir = osutils.realpath(self.test_base_dir)
439
actual = osutils.canonical_relpath(real_base_dir, 'mixedcasename')
440
self.failUnlessEqual('work/MixedCaseName', actual)
442
def test_canonical_relpath_missing_tail(self):
443
os.mkdir('MixedCaseParent')
444
# Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
445
real_base_dir = osutils.realpath(self.test_base_dir)
446
actual = osutils.canonical_relpath(real_base_dir,
447
'mixedcaseparent/nochild')
448
self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
451
class TestPumpFile(tests.TestCase):
452
"""Test pumpfile method."""
455
tests.TestCase.setUp(self)
456
# create a test datablock
457
self.block_size = 512
458
pattern = '0123456789ABCDEF'
459
self.test_data = pattern * (3 * self.block_size / len(pattern))
460
self.test_data_len = len(self.test_data)
462
def test_bracket_block_size(self):
463
"""Read data in blocks with the requested read size bracketing the
465
# make sure test data is larger than max read size
466
self.assertTrue(self.test_data_len > self.block_size)
468
from_file = file_utils.FakeReadFile(self.test_data)
471
# read (max / 2) bytes and verify read size wasn't affected
472
num_bytes_to_read = self.block_size / 2
473
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
474
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
475
self.assertEqual(from_file.get_read_count(), 1)
477
# read (max) bytes and verify read size wasn't affected
478
num_bytes_to_read = self.block_size
479
from_file.reset_read_count()
480
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
481
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
482
self.assertEqual(from_file.get_read_count(), 1)
484
# read (max + 1) bytes and verify read size was limited
485
num_bytes_to_read = self.block_size + 1
486
from_file.reset_read_count()
487
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
488
self.assertEqual(from_file.get_max_read_size(), self.block_size)
489
self.assertEqual(from_file.get_read_count(), 2)
491
# finish reading the rest of the data
492
num_bytes_to_read = self.test_data_len - to_file.tell()
493
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
495
# report error if the data wasn't equal (we only report the size due
496
# to the length of the data)
497
response_data = to_file.getvalue()
498
if response_data != self.test_data:
499
message = "Data not equal. Expected %d bytes, received %d."
500
self.fail(message % (len(response_data), self.test_data_len))
502
def test_specified_size(self):
503
"""Request a transfer larger than the maximum block size and verify
504
that the maximum read doesn't exceed the block_size."""
505
# make sure test data is larger than max read size
506
self.assertTrue(self.test_data_len > self.block_size)
508
# retrieve data in blocks
509
from_file = file_utils.FakeReadFile(self.test_data)
511
osutils.pumpfile(from_file, to_file, self.test_data_len,
514
# verify read size was equal to the maximum read size
515
self.assertTrue(from_file.get_max_read_size() > 0)
516
self.assertEqual(from_file.get_max_read_size(), self.block_size)
517
self.assertEqual(from_file.get_read_count(), 3)
519
# report error if the data wasn't equal (we only report the size due
520
# to the length of the data)
521
response_data = to_file.getvalue()
522
if response_data != self.test_data:
523
message = "Data not equal. Expected %d bytes, received %d."
524
self.fail(message % (len(response_data), self.test_data_len))
526
def test_to_eof(self):
527
"""Read to end-of-file and verify that the reads are not larger than
528
the maximum read size."""
529
# make sure test data is larger than max read size
530
self.assertTrue(self.test_data_len > self.block_size)
532
# retrieve data to EOF
533
from_file = file_utils.FakeReadFile(self.test_data)
535
osutils.pumpfile(from_file, to_file, -1, self.block_size)
537
# verify read size was equal to the maximum read size
538
self.assertEqual(from_file.get_max_read_size(), self.block_size)
539
self.assertEqual(from_file.get_read_count(), 4)
541
# report error if the data wasn't equal (we only report the size due
542
# to the length of the data)
543
response_data = to_file.getvalue()
544
if response_data != self.test_data:
545
message = "Data not equal. Expected %d bytes, received %d."
546
self.fail(message % (len(response_data), self.test_data_len))
548
def test_defaults(self):
549
"""Verifies that the default arguments will read to EOF -- this
550
test verifies that any existing usages of pumpfile will not be broken
551
with this new version."""
552
# retrieve data using default (old) pumpfile method
553
from_file = file_utils.FakeReadFile(self.test_data)
555
osutils.pumpfile(from_file, to_file)
557
# report error if the data wasn't equal (we only report the size due
558
# to the length of the data)
559
response_data = to_file.getvalue()
560
if response_data != self.test_data:
561
message = "Data not equal. Expected %d bytes, received %d."
562
self.fail(message % (len(response_data), self.test_data_len))
564
def test_report_activity(self):
566
def log_activity(length, direction):
567
activity.append((length, direction))
568
from_file = StringIO(self.test_data)
570
osutils.pumpfile(from_file, to_file, buff_size=500,
571
report_activity=log_activity, direction='read')
572
self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
573
(36, 'read')], activity)
575
from_file = StringIO(self.test_data)
578
osutils.pumpfile(from_file, to_file, buff_size=500,
579
report_activity=log_activity, direction='write')
580
self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
581
(36, 'write')], activity)
583
# And with a limited amount of data
584
from_file = StringIO(self.test_data)
587
osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
588
report_activity=log_activity, direction='read')
589
self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
593
class TestPumpStringFile(tests.TestCase):
595
def test_empty(self):
597
osutils.pump_string_file("", output)
598
self.assertEqual("", output.getvalue())
600
def test_more_than_segment_size(self):
602
osutils.pump_string_file("123456789", output, 2)
603
self.assertEqual("123456789", output.getvalue())
605
def test_segment_size(self):
607
osutils.pump_string_file("12", output, 2)
608
self.assertEqual("12", output.getvalue())
610
def test_segment_size_multiple(self):
612
osutils.pump_string_file("1234", output, 2)
613
self.assertEqual("1234", output.getvalue())
616
class TestSafeUnicode(tests.TestCase):
618
def test_from_ascii_string(self):
619
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
621
def test_from_unicode_string_ascii_contents(self):
622
self.assertEqual(u'bargam', osutils.safe_unicode(u'bargam'))
624
def test_from_unicode_string_unicode_contents(self):
625
self.assertEqual(u'bargam\xae', osutils.safe_unicode(u'bargam\xae'))
627
def test_from_utf8_string(self):
628
self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
630
def test_bad_utf8_string(self):
631
self.assertRaises(errors.BzrBadParameterNotUnicode,
632
osutils.safe_unicode,
636
class TestSafeUtf8(tests.TestCase):
638
def test_from_ascii_string(self):
640
self.assertEqual('foobar', osutils.safe_utf8(f))
642
def test_from_unicode_string_ascii_contents(self):
643
self.assertEqual('bargam', osutils.safe_utf8(u'bargam'))
645
def test_from_unicode_string_unicode_contents(self):
646
self.assertEqual('bargam\xc2\xae', osutils.safe_utf8(u'bargam\xae'))
648
def test_from_utf8_string(self):
649
self.assertEqual('foo\xc2\xae', osutils.safe_utf8('foo\xc2\xae'))
651
def test_bad_utf8_string(self):
652
self.assertRaises(errors.BzrBadParameterNotUnicode,
653
osutils.safe_utf8, '\xbb\xbb')
656
class TestSafeRevisionId(tests.TestCase):
658
def test_from_ascii_string(self):
659
# this shouldn't give a warning because it's getting an ascii string
660
self.assertEqual('foobar', osutils.safe_revision_id('foobar'))
662
def test_from_unicode_string_ascii_contents(self):
663
self.assertEqual('bargam',
664
osutils.safe_revision_id(u'bargam', warn=False))
666
def test_from_unicode_deprecated(self):
667
self.assertEqual('bargam',
668
self.callDeprecated([osutils._revision_id_warning],
669
osutils.safe_revision_id, u'bargam'))
671
def test_from_unicode_string_unicode_contents(self):
672
self.assertEqual('bargam\xc2\xae',
673
osutils.safe_revision_id(u'bargam\xae', warn=False))
675
def test_from_utf8_string(self):
676
self.assertEqual('foo\xc2\xae',
677
osutils.safe_revision_id('foo\xc2\xae'))
680
"""Currently, None is a valid revision_id"""
681
self.assertEqual(None, osutils.safe_revision_id(None))
684
class TestSafeFileId(tests.TestCase):
686
def test_from_ascii_string(self):
687
self.assertEqual('foobar', osutils.safe_file_id('foobar'))
689
def test_from_unicode_string_ascii_contents(self):
690
self.assertEqual('bargam', osutils.safe_file_id(u'bargam', warn=False))
692
def test_from_unicode_deprecated(self):
693
self.assertEqual('bargam',
694
self.callDeprecated([osutils._file_id_warning],
695
osutils.safe_file_id, u'bargam'))
697
def test_from_unicode_string_unicode_contents(self):
698
self.assertEqual('bargam\xc2\xae',
699
osutils.safe_file_id(u'bargam\xae', warn=False))
701
def test_from_utf8_string(self):
702
self.assertEqual('foo\xc2\xae',
703
osutils.safe_file_id('foo\xc2\xae'))
706
"""Currently, None is a valid revision_id"""
707
self.assertEqual(None, osutils.safe_file_id(None))
710
class TestWin32Funcs(tests.TestCase):
711
"""Test that _win32 versions of os utilities return appropriate paths."""
713
def test_abspath(self):
714
self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
715
self.assertEqual('C:/foo', osutils._win32_abspath('C:/foo'))
716
self.assertEqual('//HOST/path', osutils._win32_abspath(r'\\HOST\path'))
717
self.assertEqual('//HOST/path', osutils._win32_abspath('//HOST/path'))
719
def test_realpath(self):
720
self.assertEqual('C:/foo', osutils._win32_realpath('C:\\foo'))
721
self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
723
def test_pathjoin(self):
724
self.assertEqual('path/to/foo',
725
osutils._win32_pathjoin('path', 'to', 'foo'))
726
self.assertEqual('C:/foo',
727
osutils._win32_pathjoin('path\\to', 'C:\\foo'))
728
self.assertEqual('C:/foo',
729
osutils._win32_pathjoin('path/to', 'C:/foo'))
730
self.assertEqual('path/to/foo',
731
osutils._win32_pathjoin('path/to/', 'foo'))
732
self.assertEqual('/foo',
733
osutils._win32_pathjoin('C:/path/to/', '/foo'))
734
self.assertEqual('/foo',
735
osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
737
def test_normpath(self):
738
self.assertEqual('path/to/foo',
739
osutils._win32_normpath(r'path\\from\..\to\.\foo'))
740
self.assertEqual('path/to/foo',
741
osutils._win32_normpath('path//from/../to/./foo'))
743
def test_getcwd(self):
744
cwd = osutils._win32_getcwd()
745
os_cwd = os.getcwdu()
746
self.assertEqual(os_cwd[1:].replace('\\', '/'), cwd[1:])
747
# win32 is inconsistent whether it returns lower or upper case
748
# and even if it was consistent the user might type the other
749
# so we force it to uppercase
750
# running python.exe under cmd.exe return capital C:\\
751
# running win32 python inside a cygwin shell returns lowercase
752
self.assertEqual(os_cwd[0].upper(), cwd[0])
754
def test_fixdrive(self):
755
self.assertEqual('H:/foo', osutils._win32_fixdrive('h:/foo'))
756
self.assertEqual('H:/foo', osutils._win32_fixdrive('H:/foo'))
757
self.assertEqual('C:\\foo', osutils._win32_fixdrive('c:\\foo'))
759
def test_win98_abspath(self):
761
self.assertEqual('C:/foo', osutils._win98_abspath('C:\\foo'))
762
self.assertEqual('C:/foo', osutils._win98_abspath('C:/foo'))
764
self.assertEqual('//HOST/path', osutils._win98_abspath(r'\\HOST\path'))
765
self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
767
cwd = osutils.getcwd().rstrip('/')
768
drive = osutils._nt_splitdrive(cwd)[0]
769
self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
770
self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
773
self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
776
class TestWin32FuncsDirs(tests.TestCaseInTempDir):
777
"""Test win32 functions that create files."""
779
def test_getcwd(self):
780
self.requireFeature(tests.UnicodeFilenameFeature)
783
# TODO: jam 20060427 This will probably fail on Mac OSX because
784
# it will change the normalization of B\xe5gfors
785
# Consider using a different unicode character, or make
786
# osutils.getcwd() renormalize the path.
787
self.assertEndsWith(osutils._win32_getcwd(), u'mu-\xb5')
789
def test_minimum_path_selection(self):
790
self.assertEqual(set(),
791
osutils.minimum_path_selection([]))
792
self.assertEqual(set(['a']),
793
osutils.minimum_path_selection(['a']))
794
self.assertEqual(set(['a', 'b']),
795
osutils.minimum_path_selection(['a', 'b']))
796
self.assertEqual(set(['a/', 'b']),
797
osutils.minimum_path_selection(['a/', 'b']))
798
self.assertEqual(set(['a/', 'b']),
799
osutils.minimum_path_selection(['a/c', 'a/', 'b']))
800
self.assertEqual(set(['a-b', 'a', 'a0b']),
801
osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
803
def test_mkdtemp(self):
804
tmpdir = osutils._win32_mkdtemp(dir='.')
805
self.assertFalse('\\' in tmpdir)
807
def test_rename(self):
815
osutils._win32_rename('b', 'a')
816
self.failUnlessExists('a')
817
self.failIfExists('b')
818
self.assertFileEqual('baz\n', 'a')
820
def test_rename_missing_file(self):
826
osutils._win32_rename('b', 'a')
827
except (IOError, OSError), e:
828
self.assertEqual(errno.ENOENT, e.errno)
829
self.assertFileEqual('foo\n', 'a')
831
def test_rename_missing_dir(self):
834
osutils._win32_rename('b', 'a')
835
except (IOError, OSError), e:
836
self.assertEqual(errno.ENOENT, e.errno)
838
def test_rename_current_dir(self):
841
# You can't rename the working directory
842
# doing rename non-existant . usually
843
# just raises ENOENT, since non-existant
846
osutils._win32_rename('b', '.')
847
except (IOError, OSError), e:
848
self.assertEqual(errno.ENOENT, e.errno)
850
def test_splitpath(self):
851
def check(expected, path):
852
self.assertEqual(expected, osutils.splitpath(path))
855
check(['a', 'b'], 'a/b')
856
check(['a', 'b'], 'a/./b')
857
check(['a', '.b'], 'a/.b')
858
check(['a', '.b'], 'a\\.b')
860
self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
863
class TestParentDirectories(tests.TestCaseInTempDir):
864
"""Test osutils.parent_directories()"""
866
def test_parent_directories(self):
867
self.assertEqual([], osutils.parent_directories('a'))
868
self.assertEqual(['a'], osutils.parent_directories('a/b'))
869
self.assertEqual(['a/b', 'a'], osutils.parent_directories('a/b/c'))
872
class TestMacFuncsDirs(tests.TestCaseInTempDir):
873
"""Test mac special functions that require directories."""
875
def test_getcwd(self):
876
self.requireFeature(tests.UnicodeFilenameFeature)
877
os.mkdir(u'B\xe5gfors')
878
os.chdir(u'B\xe5gfors')
879
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
881
def test_getcwd_nonnorm(self):
882
self.requireFeature(tests.UnicodeFilenameFeature)
883
# Test that _mac_getcwd() will normalize this path
884
os.mkdir(u'Ba\u030agfors')
885
os.chdir(u'Ba\u030agfors')
886
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
889
class TestChunksToLines(tests.TestCase):
891
def test_smoketest(self):
892
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
893
osutils.chunks_to_lines(['foo\nbar', '\nbaz\n']))
894
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
895
osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
897
def test_osutils_binding(self):
898
from bzrlib.tests import test__chunks_to_lines
899
if test__chunks_to_lines.CompiledChunksToLinesFeature.available():
900
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
902
from bzrlib._chunks_to_lines_py import chunks_to_lines
903
self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
906
class TestSplitLines(tests.TestCase):
908
def test_split_unicode(self):
909
self.assertEqual([u'foo\n', u'bar\xae'],
910
osutils.split_lines(u'foo\nbar\xae'))
911
self.assertEqual([u'foo\n', u'bar\xae\n'],
912
osutils.split_lines(u'foo\nbar\xae\n'))
914
def test_split_with_carriage_returns(self):
915
self.assertEqual(['foo\rbar\n'],
916
osutils.split_lines('foo\rbar\n'))
919
class TestWalkDirs(tests.TestCaseInTempDir):
921
def assertExpectedBlocks(self, expected, result):
922
self.assertEqual(expected,
923
[(dirinfo, [line[0:3] for line in block])
924
for dirinfo, block in result])
926
def test_walkdirs(self):
935
self.build_tree(tree)
936
expected_dirblocks = [
938
[('0file', '0file', 'file'),
939
('1dir', '1dir', 'directory'),
940
('2file', '2file', 'file'),
944
[('1dir/0file', '0file', 'file'),
945
('1dir/1dir', '1dir', 'directory'),
948
(('1dir/1dir', './1dir/1dir'),
955
for dirdetail, dirblock in osutils.walkdirs('.'):
956
if len(dirblock) and dirblock[0][1] == '.bzr':
957
# this tests the filtering of selected paths
960
result.append((dirdetail, dirblock))
962
self.assertTrue(found_bzrdir)
963
self.assertExpectedBlocks(expected_dirblocks, result)
964
# you can search a subdir only, with a supplied prefix.
966
for dirblock in osutils.walkdirs('./1dir', '1dir'):
967
result.append(dirblock)
968
self.assertExpectedBlocks(expected_dirblocks[1:], result)
970
def test_walkdirs_os_error(self):
971
# <https://bugs.edge.launchpad.net/bzr/+bug/338653>
972
# Pyrex readdir didn't raise useful messages if it had an error
973
# reading the directory
974
if sys.platform == 'win32':
975
raise tests.TestNotApplicable(
976
"readdir IOError not tested on win32")
977
os.mkdir("test-unreadable")
978
os.chmod("test-unreadable", 0000)
979
# must chmod it back so that it can be removed
980
self.addCleanup(os.chmod, "test-unreadable", 0700)
981
# The error is not raised until the generator is actually evaluated.
982
# (It would be ok if it happened earlier but at the moment it
984
e = self.assertRaises(OSError, list, osutils._walkdirs_utf8("."))
985
self.assertEquals('./test-unreadable', e.filename)
986
self.assertEquals(errno.EACCES, e.errno)
987
# Ensure the message contains the file name
988
self.assertContainsRe(str(e), "\./test-unreadable")
990
def test__walkdirs_utf8(self):
999
self.build_tree(tree)
1000
expected_dirblocks = [
1002
[('0file', '0file', 'file'),
1003
('1dir', '1dir', 'directory'),
1004
('2file', '2file', 'file'),
1007
(('1dir', './1dir'),
1008
[('1dir/0file', '0file', 'file'),
1009
('1dir/1dir', '1dir', 'directory'),
1012
(('1dir/1dir', './1dir/1dir'),
1018
found_bzrdir = False
1019
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1020
if len(dirblock) and dirblock[0][1] == '.bzr':
1021
# this tests the filtering of selected paths
1024
result.append((dirdetail, dirblock))
1026
self.assertTrue(found_bzrdir)
1027
self.assertExpectedBlocks(expected_dirblocks, result)
1029
# you can search a subdir only, with a supplied prefix.
1031
for dirblock in osutils.walkdirs('./1dir', '1dir'):
1032
result.append(dirblock)
1033
self.assertExpectedBlocks(expected_dirblocks[1:], result)
1035
def _filter_out_stat(self, result):
1036
"""Filter out the stat value from the walkdirs result"""
1037
for dirdetail, dirblock in result:
1039
for info in dirblock:
1040
# Ignore info[3] which is the stat
1041
new_dirblock.append((info[0], info[1], info[2], info[4]))
1042
dirblock[:] = new_dirblock
1044
def _save_platform_info(self):
1045
cur_winver = win32utils.winver
1046
cur_fs_enc = osutils._fs_enc
1047
cur_dir_reader = osutils._selected_dir_reader
1049
win32utils.winver = cur_winver
1050
osutils._fs_enc = cur_fs_enc
1051
osutils._selected_dir_reader = cur_dir_reader
1052
self.addCleanup(restore)
1054
def assertDirReaderIs(self, expected):
1055
"""Assert the right implementation for _walkdirs_utf8 is chosen."""
1056
# Force it to redetect
1057
osutils._selected_dir_reader = None
1058
# Nothing to list, but should still trigger the selection logic
1059
self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
1060
self.assertIsInstance(osutils._selected_dir_reader, expected)
1062
def test_force_walkdirs_utf8_fs_utf8(self):
1063
self.requireFeature(UTF8DirReaderFeature)
1064
self._save_platform_info()
1065
win32utils.winver = None # Avoid the win32 detection code
1066
osutils._fs_enc = 'UTF-8'
1067
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1069
def test_force_walkdirs_utf8_fs_ascii(self):
1070
self.requireFeature(UTF8DirReaderFeature)
1071
self._save_platform_info()
1072
win32utils.winver = None # Avoid the win32 detection code
1073
osutils._fs_enc = 'US-ASCII'
1074
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1076
def test_force_walkdirs_utf8_fs_ANSI(self):
1077
self.requireFeature(UTF8DirReaderFeature)
1078
self._save_platform_info()
1079
win32utils.winver = None # Avoid the win32 detection code
1080
osutils._fs_enc = 'ANSI_X3.4-1968'
1081
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1083
def test_force_walkdirs_utf8_fs_latin1(self):
1084
self._save_platform_info()
1085
win32utils.winver = None # Avoid the win32 detection code
1086
osutils._fs_enc = 'latin1'
1087
self.assertDirReaderIs(osutils.UnicodeDirReader)
1089
def test_force_walkdirs_utf8_nt(self):
1090
# Disabled because the thunk of the whole walkdirs api is disabled.
1091
self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1092
self._save_platform_info()
1093
win32utils.winver = 'Windows NT'
1094
from bzrlib._walkdirs_win32 import Win32ReadDir
1095
self.assertDirReaderIs(Win32ReadDir)
1097
def test_force_walkdirs_utf8_98(self):
1098
self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1099
self._save_platform_info()
1100
win32utils.winver = 'Windows 98'
1101
self.assertDirReaderIs(osutils.UnicodeDirReader)
1103
def test_unicode_walkdirs(self):
1104
"""Walkdirs should always return unicode paths."""
1105
self.requireFeature(tests.UnicodeFilenameFeature)
1106
name0 = u'0file-\xb6'
1107
name1 = u'1dir-\u062c\u0648'
1108
name2 = u'2file-\u0633'
1112
name1 + '/' + name0,
1113
name1 + '/' + name1 + '/',
1116
self.build_tree(tree)
1117
expected_dirblocks = [
1119
[(name0, name0, 'file', './' + name0),
1120
(name1, name1, 'directory', './' + name1),
1121
(name2, name2, 'file', './' + name2),
1124
((name1, './' + name1),
1125
[(name1 + '/' + name0, name0, 'file', './' + name1
1127
(name1 + '/' + name1, name1, 'directory', './' + name1
1131
((name1 + '/' + name1, './' + name1 + '/' + name1),
1136
result = list(osutils.walkdirs('.'))
1137
self._filter_out_stat(result)
1138
self.assertEqual(expected_dirblocks, result)
1139
result = list(osutils.walkdirs(u'./'+name1, name1))
1140
self._filter_out_stat(result)
1141
self.assertEqual(expected_dirblocks[1:], result)
1143
def test_unicode__walkdirs_utf8(self):
1144
"""Walkdirs_utf8 should always return utf8 paths.
1146
The abspath portion might be in unicode or utf-8
1148
self.requireFeature(tests.UnicodeFilenameFeature)
1149
name0 = u'0file-\xb6'
1150
name1 = u'1dir-\u062c\u0648'
1151
name2 = u'2file-\u0633'
1155
name1 + '/' + name0,
1156
name1 + '/' + name1 + '/',
1159
self.build_tree(tree)
1160
name0 = name0.encode('utf8')
1161
name1 = name1.encode('utf8')
1162
name2 = name2.encode('utf8')
1164
expected_dirblocks = [
1166
[(name0, name0, 'file', './' + name0),
1167
(name1, name1, 'directory', './' + name1),
1168
(name2, name2, 'file', './' + name2),
1171
((name1, './' + name1),
1172
[(name1 + '/' + name0, name0, 'file', './' + name1
1174
(name1 + '/' + name1, name1, 'directory', './' + name1
1178
((name1 + '/' + name1, './' + name1 + '/' + name1),
1184
# For ease in testing, if walkdirs_utf8 returns Unicode, assert that
1185
# all abspaths are Unicode, and encode them back into utf8.
1186
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1187
self.assertIsInstance(dirdetail[0], str)
1188
if isinstance(dirdetail[1], unicode):
1189
dirdetail = (dirdetail[0], dirdetail[1].encode('utf8'))
1190
dirblock = [list(info) for info in dirblock]
1191
for info in dirblock:
1192
self.assertIsInstance(info[4], unicode)
1193
info[4] = info[4].encode('utf8')
1195
for info in dirblock:
1196
self.assertIsInstance(info[0], str)
1197
self.assertIsInstance(info[1], str)
1198
self.assertIsInstance(info[4], str)
1199
# Remove the stat information
1200
new_dirblock.append((info[0], info[1], info[2], info[4]))
1201
result.append((dirdetail, new_dirblock))
1202
self.assertEqual(expected_dirblocks, result)
1204
def test__walkdirs_utf8_with_unicode_fs(self):
1205
"""UnicodeDirReader should be a safe fallback everywhere
1207
The abspath portion should be in unicode
1209
self.requireFeature(tests.UnicodeFilenameFeature)
1210
# Use the unicode reader. TODO: split into driver-and-driven unit
1212
self._save_platform_info()
1213
osutils._selected_dir_reader = osutils.UnicodeDirReader()
1214
name0u = u'0file-\xb6'
1215
name1u = u'1dir-\u062c\u0648'
1216
name2u = u'2file-\u0633'
1220
name1u + '/' + name0u,
1221
name1u + '/' + name1u + '/',
1224
self.build_tree(tree)
1225
name0 = name0u.encode('utf8')
1226
name1 = name1u.encode('utf8')
1227
name2 = name2u.encode('utf8')
1229
# All of the abspaths should be in unicode, all of the relative paths
1231
expected_dirblocks = [
1233
[(name0, name0, 'file', './' + name0u),
1234
(name1, name1, 'directory', './' + name1u),
1235
(name2, name2, 'file', './' + name2u),
1238
((name1, './' + name1u),
1239
[(name1 + '/' + name0, name0, 'file', './' + name1u
1241
(name1 + '/' + name1, name1, 'directory', './' + name1u
1245
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1250
result = list(osutils._walkdirs_utf8('.'))
1251
self._filter_out_stat(result)
1252
self.assertEqual(expected_dirblocks, result)
1254
def test__walkdirs_utf8_win32readdir(self):
1255
self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1256
self.requireFeature(tests.UnicodeFilenameFeature)
1257
from bzrlib._walkdirs_win32 import Win32ReadDir
1258
self._save_platform_info()
1259
osutils._selected_dir_reader = Win32ReadDir()
1260
name0u = u'0file-\xb6'
1261
name1u = u'1dir-\u062c\u0648'
1262
name2u = u'2file-\u0633'
1266
name1u + '/' + name0u,
1267
name1u + '/' + name1u + '/',
1270
self.build_tree(tree)
1271
name0 = name0u.encode('utf8')
1272
name1 = name1u.encode('utf8')
1273
name2 = name2u.encode('utf8')
1275
# All of the abspaths should be in unicode, all of the relative paths
1277
expected_dirblocks = [
1279
[(name0, name0, 'file', './' + name0u),
1280
(name1, name1, 'directory', './' + name1u),
1281
(name2, name2, 'file', './' + name2u),
1284
((name1, './' + name1u),
1285
[(name1 + '/' + name0, name0, 'file', './' + name1u
1287
(name1 + '/' + name1, name1, 'directory', './' + name1u
1291
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1296
result = list(osutils._walkdirs_utf8(u'.'))
1297
self._filter_out_stat(result)
1298
self.assertEqual(expected_dirblocks, result)
1300
def assertStatIsCorrect(self, path, win32stat):
1301
os_stat = os.stat(path)
1302
self.assertEqual(os_stat.st_size, win32stat.st_size)
1303
self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
1304
self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
1305
self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
1306
self.assertEqual(os_stat.st_dev, win32stat.st_dev)
1307
self.assertEqual(os_stat.st_ino, win32stat.st_ino)
1308
self.assertEqual(os_stat.st_mode, win32stat.st_mode)
1310
def test__walkdirs_utf_win32_find_file_stat_file(self):
1311
"""make sure our Stat values are valid"""
1312
self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1313
self.requireFeature(tests.UnicodeFilenameFeature)
1314
from bzrlib._walkdirs_win32 import Win32ReadDir
1315
name0u = u'0file-\xb6'
1316
name0 = name0u.encode('utf8')
1317
self.build_tree([name0u])
1318
# I hate to sleep() here, but I'm trying to make the ctime different
1321
f = open(name0u, 'ab')
1323
f.write('just a small update')
1327
result = Win32ReadDir().read_dir('', u'.')
1329
self.assertEqual((name0, name0, 'file'), entry[:3])
1330
self.assertEqual(u'./' + name0u, entry[4])
1331
self.assertStatIsCorrect(entry[4], entry[3])
1332
self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
1334
def test__walkdirs_utf_win32_find_file_stat_directory(self):
1335
"""make sure our Stat values are valid"""
1336
self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1337
self.requireFeature(tests.UnicodeFilenameFeature)
1338
from bzrlib._walkdirs_win32 import Win32ReadDir
1339
name0u = u'0dir-\u062c\u0648'
1340
name0 = name0u.encode('utf8')
1341
self.build_tree([name0u + '/'])
1343
result = Win32ReadDir().read_dir('', u'.')
1345
self.assertEqual((name0, name0, 'directory'), entry[:3])
1346
self.assertEqual(u'./' + name0u, entry[4])
1347
self.assertStatIsCorrect(entry[4], entry[3])
1349
def assertPathCompare(self, path_less, path_greater):
1350
"""check that path_less and path_greater compare correctly."""
1351
self.assertEqual(0, osutils.compare_paths_prefix_order(
1352
path_less, path_less))
1353
self.assertEqual(0, osutils.compare_paths_prefix_order(
1354
path_greater, path_greater))
1355
self.assertEqual(-1, osutils.compare_paths_prefix_order(
1356
path_less, path_greater))
1357
self.assertEqual(1, osutils.compare_paths_prefix_order(
1358
path_greater, path_less))
1360
def test_compare_paths_prefix_order(self):
1361
# root before all else
1362
self.assertPathCompare("/", "/a")
1363
# alpha within a dir
1364
self.assertPathCompare("/a", "/b")
1365
self.assertPathCompare("/b", "/z")
1366
# high dirs before lower.
1367
self.assertPathCompare("/z", "/a/a")
1368
# except if the deeper dir should be output first
1369
self.assertPathCompare("/a/b/c", "/d/g")
1370
# lexical betwen dirs of the same height
1371
self.assertPathCompare("/a/z", "/z/z")
1372
self.assertPathCompare("/a/c/z", "/a/d/e")
1374
# this should also be consistent for no leading / paths
1375
# root before all else
1376
self.assertPathCompare("", "a")
1377
# alpha within a dir
1378
self.assertPathCompare("a", "b")
1379
self.assertPathCompare("b", "z")
1380
# high dirs before lower.
1381
self.assertPathCompare("z", "a/a")
1382
# except if the deeper dir should be output first
1383
self.assertPathCompare("a/b/c", "d/g")
1384
# lexical betwen dirs of the same height
1385
self.assertPathCompare("a/z", "z/z")
1386
self.assertPathCompare("a/c/z", "a/d/e")
1388
def test_path_prefix_sorting(self):
1389
"""Doing a sort on path prefix should match our sample data."""
1404
dir_sorted_paths = [
1420
sorted(original_paths, key=osutils.path_prefix_key))
1421
# using the comparison routine shoudl work too:
1424
sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
1427
class TestCopyTree(tests.TestCaseInTempDir):
1429
def test_copy_basic_tree(self):
1430
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1431
osutils.copy_tree('source', 'target')
1432
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1433
self.assertEqual(['c'], os.listdir('target/b'))
1435
def test_copy_tree_target_exists(self):
1436
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c',
1438
osutils.copy_tree('source', 'target')
1439
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1440
self.assertEqual(['c'], os.listdir('target/b'))
1442
def test_copy_tree_symlinks(self):
1443
self.requireFeature(tests.SymlinkFeature)
1444
self.build_tree(['source/'])
1445
os.symlink('a/generic/path', 'source/lnk')
1446
osutils.copy_tree('source', 'target')
1447
self.assertEqual(['lnk'], os.listdir('target'))
1448
self.assertEqual('a/generic/path', os.readlink('target/lnk'))
1450
def test_copy_tree_handlers(self):
1451
processed_files = []
1452
processed_links = []
1453
def file_handler(from_path, to_path):
1454
processed_files.append(('f', from_path, to_path))
1455
def dir_handler(from_path, to_path):
1456
processed_files.append(('d', from_path, to_path))
1457
def link_handler(from_path, to_path):
1458
processed_links.append((from_path, to_path))
1459
handlers = {'file':file_handler,
1460
'directory':dir_handler,
1461
'symlink':link_handler,
1464
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1465
if osutils.has_symlinks():
1466
os.symlink('a/generic/path', 'source/lnk')
1467
osutils.copy_tree('source', 'target', handlers=handlers)
1469
self.assertEqual([('d', 'source', 'target'),
1470
('f', 'source/a', 'target/a'),
1471
('d', 'source/b', 'target/b'),
1472
('f', 'source/b/c', 'target/b/c'),
1474
self.failIfExists('target')
1475
if osutils.has_symlinks():
1476
self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1479
class TestSetUnsetEnv(tests.TestCase):
1480
"""Test updating the environment"""
1483
super(TestSetUnsetEnv, self).setUp()
1485
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
1486
'Environment was not cleaned up properly.'
1487
' Variable BZR_TEST_ENV_VAR should not exist.')
1489
if 'BZR_TEST_ENV_VAR' in os.environ:
1490
del os.environ['BZR_TEST_ENV_VAR']
1492
self.addCleanup(cleanup)
1495
"""Test that we can set an env variable"""
1496
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1497
self.assertEqual(None, old)
1498
self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
1500
def test_double_set(self):
1501
"""Test that we get the old value out"""
1502
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1503
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
1504
self.assertEqual('foo', old)
1505
self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
1507
def test_unicode(self):
1508
"""Environment can only contain plain strings
1510
So Unicode strings must be encoded.
1512
uni_val, env_val = tests.probe_unicode_in_user_encoding()
1514
raise tests.TestSkipped(
1515
'Cannot find a unicode character that works in encoding %s'
1516
% (osutils.get_user_encoding(),))
1518
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1519
self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
1521
def test_unset(self):
1522
"""Test that passing None will remove the env var"""
1523
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1524
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1525
self.assertEqual('foo', old)
1526
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1527
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1530
class TestSizeShaFile(tests.TestCaseInTempDir):
1532
def test_sha_empty(self):
1533
self.build_tree_contents([('foo', '')])
1534
expected_sha = osutils.sha_string('')
1536
self.addCleanup(f.close)
1537
size, sha = osutils.size_sha_file(f)
1538
self.assertEqual(0, size)
1539
self.assertEqual(expected_sha, sha)
1541
def test_sha_mixed_endings(self):
1542
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1543
self.build_tree_contents([('foo', text)])
1544
expected_sha = osutils.sha_string(text)
1546
self.addCleanup(f.close)
1547
size, sha = osutils.size_sha_file(f)
1548
self.assertEqual(38, size)
1549
self.assertEqual(expected_sha, sha)
1552
class TestShaFileByName(tests.TestCaseInTempDir):
1554
def test_sha_empty(self):
1555
self.build_tree_contents([('foo', '')])
1556
expected_sha = osutils.sha_string('')
1557
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1559
def test_sha_mixed_endings(self):
1560
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1561
self.build_tree_contents([('foo', text)])
1562
expected_sha = osutils.sha_string(text)
1563
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1566
class TestResourceLoading(tests.TestCaseInTempDir):
1568
def test_resource_string(self):
1569
# test resource in bzrlib
1570
text = osutils.resource_string('bzrlib', 'debug.py')
1571
self.assertContainsRe(text, "debug_flags = set()")
1572
# test resource under bzrlib
1573
text = osutils.resource_string('bzrlib.ui', 'text.py')
1574
self.assertContainsRe(text, "class TextUIFactory")
1575
# test unsupported package
1576
self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1578
# test unknown resource
1579
self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1582
class TestReCompile(tests.TestCase):
1584
def test_re_compile_checked(self):
1585
r = osutils.re_compile_checked(r'A*', re.IGNORECASE)
1586
self.assertTrue(r.match('aaaa'))
1587
self.assertTrue(r.match('aAaA'))
1589
def test_re_compile_checked_error(self):
1590
# like https://bugs.launchpad.net/bzr/+bug/251352
1591
err = self.assertRaises(
1592
errors.BzrCommandError,
1593
osutils.re_compile_checked, '*', re.IGNORECASE, 'test case')
1595
"Invalid regular expression in test case: '*': "
1596
"nothing to repeat",
1600
class TestDirReader(tests.TestCaseInTempDir):
1603
_dir_reader_class = None
1604
_native_to_unicode = None
1607
tests.TestCaseInTempDir.setUp(self)
1609
# Save platform specific info and reset it
1610
cur_dir_reader = osutils._selected_dir_reader
1613
osutils._selected_dir_reader = cur_dir_reader
1614
self.addCleanup(restore)
1616
osutils._selected_dir_reader = self._dir_reader_class()
1618
def _get_ascii_tree(self):
1626
expected_dirblocks = [
1628
[('0file', '0file', 'file'),
1629
('1dir', '1dir', 'directory'),
1630
('2file', '2file', 'file'),
1633
(('1dir', './1dir'),
1634
[('1dir/0file', '0file', 'file'),
1635
('1dir/1dir', '1dir', 'directory'),
1638
(('1dir/1dir', './1dir/1dir'),
1643
return tree, expected_dirblocks
1645
def test_walk_cur_dir(self):
1646
tree, expected_dirblocks = self._get_ascii_tree()
1647
self.build_tree(tree)
1648
result = list(osutils._walkdirs_utf8('.'))
1649
# Filter out stat and abspath
1650
self.assertEqual(expected_dirblocks,
1651
[(dirinfo, [line[0:3] for line in block])
1652
for dirinfo, block in result])
1654
def test_walk_sub_dir(self):
1655
tree, expected_dirblocks = self._get_ascii_tree()
1656
self.build_tree(tree)
1657
# you can search a subdir only, with a supplied prefix.
1658
result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1659
# Filter out stat and abspath
1660
self.assertEqual(expected_dirblocks[1:],
1661
[(dirinfo, [line[0:3] for line in block])
1662
for dirinfo, block in result])
1664
def _get_unicode_tree(self):
1665
name0u = u'0file-\xb6'
1666
name1u = u'1dir-\u062c\u0648'
1667
name2u = u'2file-\u0633'
1671
name1u + '/' + name0u,
1672
name1u + '/' + name1u + '/',
1675
name0 = name0u.encode('UTF-8')
1676
name1 = name1u.encode('UTF-8')
1677
name2 = name2u.encode('UTF-8')
1678
expected_dirblocks = [
1680
[(name0, name0, 'file', './' + name0u),
1681
(name1, name1, 'directory', './' + name1u),
1682
(name2, name2, 'file', './' + name2u),
1685
((name1, './' + name1u),
1686
[(name1 + '/' + name0, name0, 'file', './' + name1u
1688
(name1 + '/' + name1, name1, 'directory', './' + name1u
1692
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1697
return tree, expected_dirblocks
1699
def _filter_out(self, raw_dirblocks):
1700
"""Filter out a walkdirs_utf8 result.
1702
stat field is removed, all native paths are converted to unicode
1704
filtered_dirblocks = []
1705
for dirinfo, block in raw_dirblocks:
1706
dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1709
details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1710
filtered_dirblocks.append((dirinfo, details))
1711
return filtered_dirblocks
1713
def test_walk_unicode_tree(self):
1714
self.requireFeature(tests.UnicodeFilenameFeature)
1715
tree, expected_dirblocks = self._get_unicode_tree()
1716
self.build_tree(tree)
1717
result = list(osutils._walkdirs_utf8('.'))
1718
self.assertEqual(expected_dirblocks, self._filter_out(result))
1720
def test_symlink(self):
1721
self.requireFeature(tests.SymlinkFeature)
1722
self.requireFeature(tests.UnicodeFilenameFeature)
1723
target = u'target\N{Euro Sign}'
1724
link_name = u'l\N{Euro Sign}nk'
1725
os.symlink(target, link_name)
1726
target_utf8 = target.encode('UTF-8')
1727
link_name_utf8 = link_name.encode('UTF-8')
1728
expected_dirblocks = [
1730
[(link_name_utf8, link_name_utf8,
1731
'symlink', './' + link_name),],
1733
result = list(osutils._walkdirs_utf8('.'))
1734
self.assertEqual(expected_dirblocks, self._filter_out(result))
1737
class TestReadLink(tests.TestCaseInTempDir):
1738
"""Exposes os.readlink() problems and the osutils solution.
1740
The only guarantee offered by os.readlink(), starting with 2.6, is that a
1741
unicode string will be returned if a unicode string is passed.
1743
But prior python versions failed to properly encode the passed unicode
1746
_test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
1749
super(tests.TestCaseInTempDir, self).setUp()
1750
self.link = u'l\N{Euro Sign}ink'
1751
self.target = u'targe\N{Euro Sign}t'
1752
os.symlink(self.target, self.link)
1754
def test_os_readlink_link_encoding(self):
1755
if sys.version_info < (2, 6):
1756
self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
1758
self.assertEquals(self.target, os.readlink(self.link))
1760
def test_os_readlink_link_decoding(self):
1761
self.assertEquals(self.target.encode(osutils._fs_enc),
1762
os.readlink(self.link.encode(osutils._fs_enc)))
1765
class TestConcurrency(tests.TestCase):
1767
def test_local_concurrency(self):
1768
concurrency = osutils.local_concurrency()
1769
self.assertIsInstance(concurrency, int)
added
removed
bzrlib/tests/test_osutils.py
