1
# Copyright (C) 2005, 2006 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Tests for the osutils wrapper."""
31
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
32
from bzrlib.tests import (
40
class TestOSUtils(TestCaseInTempDir):
42
def test_contains_whitespace(self):
43
self.failUnless(osutils.contains_whitespace(u' '))
44
self.failUnless(osutils.contains_whitespace(u'hello there'))
45
self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
46
self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
47
self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
48
self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
50
# \xa0 is "Non-breaking-space" which on some python locales thinks it
51
# is whitespace, but we do not.
52
self.failIf(osutils.contains_whitespace(u''))
53
self.failIf(osutils.contains_whitespace(u'hellothere'))
54
self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
56
def test_fancy_rename(self):
57
# This should work everywhere
59
osutils.fancy_rename(a, b,
60
rename_func=os.rename,
61
unlink_func=os.unlink)
63
open('a', 'wb').write('something in a\n')
65
self.failIfExists('a')
66
self.failUnlessExists('b')
67
self.check_file_contents('b', 'something in a\n')
69
open('a', 'wb').write('new something in a\n')
72
self.check_file_contents('a', 'something in a\n')
74
def test_rename(self):
75
# Rename should be semi-atomic on all platforms
76
open('a', 'wb').write('something in a\n')
77
osutils.rename('a', 'b')
78
self.failIfExists('a')
79
self.failUnlessExists('b')
80
self.check_file_contents('b', 'something in a\n')
82
open('a', 'wb').write('new something in a\n')
83
osutils.rename('b', 'a')
85
self.check_file_contents('a', 'something in a\n')
87
# TODO: test fancy_rename using a MemoryTransport
89
def test_01_rand_chars_empty(self):
90
result = osutils.rand_chars(0)
91
self.assertEqual(result, '')
93
def test_02_rand_chars_100(self):
94
result = osutils.rand_chars(100)
95
self.assertEqual(len(result), 100)
96
self.assertEqual(type(result), str)
97
self.assertContainsRe(result, r'^[a-z0-9]{100}$')
99
def test_is_inside(self):
100
is_inside = osutils.is_inside
101
self.assertTrue(is_inside('src', 'src/foo.c'))
102
self.assertFalse(is_inside('src', 'srccontrol'))
103
self.assertTrue(is_inside('src', 'src/a/a/a/foo.c'))
104
self.assertTrue(is_inside('foo.c', 'foo.c'))
105
self.assertFalse(is_inside('foo.c', ''))
106
self.assertTrue(is_inside('', 'foo.c'))
108
def test_rmtree(self):
109
# Check to remove tree with read-only files/dirs
111
f = file('dir/file', 'w')
114
# would like to also try making the directory readonly, but at the
115
# moment python shutil.rmtree doesn't handle that properly - it would
116
# need to chmod the directory before removing things inside it - deferred
117
# for now -- mbp 20060505
118
# osutils.make_readonly('dir')
119
osutils.make_readonly('dir/file')
121
osutils.rmtree('dir')
123
self.failIfExists('dir/file')
124
self.failIfExists('dir')
126
def test_file_kind(self):
127
self.build_tree(['file', 'dir/'])
128
self.assertEquals('file', osutils.file_kind('file'))
129
self.assertEquals('directory', osutils.file_kind('dir/'))
130
if osutils.has_symlinks():
131
os.symlink('symlink', 'symlink')
132
self.assertEquals('symlink', osutils.file_kind('symlink'))
134
# TODO: jam 20060529 Test a block device
136
os.lstat('/dev/null')
138
if e.errno not in (errno.ENOENT,):
141
self.assertEquals('chardev', osutils.file_kind('/dev/null'))
143
mkfifo = getattr(os, 'mkfifo', None)
147
self.assertEquals('fifo', osutils.file_kind('fifo'))
151
AF_UNIX = getattr(socket, 'AF_UNIX', None)
153
s = socket.socket(AF_UNIX)
156
self.assertEquals('socket', osutils.file_kind('socket'))
160
def test_get_umask(self):
161
if sys.platform == 'win32':
162
# umask always returns '0', no way to set it
163
self.assertEqual(0, osutils.get_umask())
166
orig_umask = osutils.get_umask()
169
self.assertEqual(0222, osutils.get_umask())
171
self.assertEqual(0022, osutils.get_umask())
173
self.assertEqual(0002, osutils.get_umask())
175
self.assertEqual(0027, osutils.get_umask())
179
def assertFormatedDelta(self, expected, seconds):
180
"""Assert osutils.format_delta formats as expected"""
181
actual = osutils.format_delta(seconds)
182
self.assertEqual(expected, actual)
184
def test_format_delta(self):
185
self.assertFormatedDelta('0 seconds ago', 0)
186
self.assertFormatedDelta('1 second ago', 1)
187
self.assertFormatedDelta('10 seconds ago', 10)
188
self.assertFormatedDelta('59 seconds ago', 59)
189
self.assertFormatedDelta('89 seconds ago', 89)
190
self.assertFormatedDelta('1 minute, 30 seconds ago', 90)
191
self.assertFormatedDelta('3 minutes, 0 seconds ago', 180)
192
self.assertFormatedDelta('3 minutes, 1 second ago', 181)
193
self.assertFormatedDelta('10 minutes, 15 seconds ago', 615)
194
self.assertFormatedDelta('30 minutes, 59 seconds ago', 1859)
195
self.assertFormatedDelta('31 minutes, 0 seconds ago', 1860)
196
self.assertFormatedDelta('60 minutes, 0 seconds ago', 3600)
197
self.assertFormatedDelta('89 minutes, 59 seconds ago', 5399)
198
self.assertFormatedDelta('1 hour, 30 minutes ago', 5400)
199
self.assertFormatedDelta('2 hours, 30 minutes ago', 9017)
200
self.assertFormatedDelta('10 hours, 0 minutes ago', 36000)
201
self.assertFormatedDelta('24 hours, 0 minutes ago', 86400)
202
self.assertFormatedDelta('35 hours, 59 minutes ago', 129599)
203
self.assertFormatedDelta('36 hours, 0 minutes ago', 129600)
204
self.assertFormatedDelta('36 hours, 0 minutes ago', 129601)
205
self.assertFormatedDelta('36 hours, 1 minute ago', 129660)
206
self.assertFormatedDelta('36 hours, 1 minute ago', 129661)
207
self.assertFormatedDelta('84 hours, 10 minutes ago', 303002)
209
# We handle when time steps the wrong direction because computers
210
# don't have synchronized clocks.
211
self.assertFormatedDelta('84 hours, 10 minutes in the future', -303002)
212
self.assertFormatedDelta('1 second in the future', -1)
213
self.assertFormatedDelta('2 seconds in the future', -2)
215
def test_dereference_path(self):
216
if not osutils.has_symlinks():
217
raise TestSkipped('Symlinks are not supported on this platform')
218
cwd = osutils.realpath('.')
220
bar_path = osutils.pathjoin(cwd, 'bar')
221
# Using './' to avoid bug #1213894 (first path component not
222
# dereferenced) in Python 2.4.1 and earlier
223
self.assertEqual(bar_path, osutils.realpath('./bar'))
224
os.symlink('bar', 'foo')
225
self.assertEqual(bar_path, osutils.realpath('./foo'))
227
# Does not dereference terminal symlinks
228
foo_path = osutils.pathjoin(cwd, 'foo')
229
self.assertEqual(foo_path, osutils.dereference_path('./foo'))
231
# Dereferences parent symlinks
233
baz_path = osutils.pathjoin(bar_path, 'baz')
234
self.assertEqual(baz_path, osutils.dereference_path('./foo/baz'))
236
# Dereferences parent symlinks that are the first path element
237
self.assertEqual(baz_path, osutils.dereference_path('foo/baz'))
239
# Dereferences parent symlinks in absolute paths
240
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
241
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
244
class TestSafeUnicode(TestCase):
246
def test_from_ascii_string(self):
247
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
249
def test_from_unicode_string_ascii_contents(self):
250
self.assertEqual(u'bargam', osutils.safe_unicode(u'bargam'))
252
def test_from_unicode_string_unicode_contents(self):
253
self.assertEqual(u'bargam\xae', osutils.safe_unicode(u'bargam\xae'))
255
def test_from_utf8_string(self):
256
self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
258
def test_bad_utf8_string(self):
259
self.assertRaises(BzrBadParameterNotUnicode,
260
osutils.safe_unicode,
264
class TestWin32Funcs(TestCase):
265
"""Test that the _win32 versions of os utilities return appropriate paths."""
267
def test_abspath(self):
268
self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
269
self.assertEqual('C:/foo', osutils._win32_abspath('C:/foo'))
270
self.assertEqual('//HOST/path', osutils._win32_abspath(r'\\HOST\path'))
271
self.assertEqual('//HOST/path', osutils._win32_abspath('//HOST/path'))
273
def test_realpath(self):
274
self.assertEqual('C:/foo', osutils._win32_realpath('C:\\foo'))
275
self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
277
def test_pathjoin(self):
278
self.assertEqual('path/to/foo', osutils._win32_pathjoin('path', 'to', 'foo'))
279
self.assertEqual('C:/foo', osutils._win32_pathjoin('path\\to', 'C:\\foo'))
280
self.assertEqual('C:/foo', osutils._win32_pathjoin('path/to', 'C:/foo'))
281
self.assertEqual('path/to/foo', osutils._win32_pathjoin('path/to/', 'foo'))
282
self.assertEqual('/foo', osutils._win32_pathjoin('C:/path/to/', '/foo'))
283
self.assertEqual('/foo', osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
285
def test_normpath(self):
286
self.assertEqual('path/to/foo', osutils._win32_normpath(r'path\\from\..\to\.\foo'))
287
self.assertEqual('path/to/foo', osutils._win32_normpath('path//from/../to/./foo'))
289
def test_getcwd(self):
290
cwd = osutils._win32_getcwd()
291
os_cwd = os.getcwdu()
292
self.assertEqual(os_cwd[1:].replace('\\', '/'), cwd[1:])
293
# win32 is inconsistent whether it returns lower or upper case
294
# and even if it was consistent the user might type the other
295
# so we force it to uppercase
296
# running python.exe under cmd.exe return capital C:\\
297
# running win32 python inside a cygwin shell returns lowercase
298
self.assertEqual(os_cwd[0].upper(), cwd[0])
300
def test_fixdrive(self):
301
self.assertEqual('H:/foo', osutils._win32_fixdrive('h:/foo'))
302
self.assertEqual('H:/foo', osutils._win32_fixdrive('H:/foo'))
303
self.assertEqual('C:\\foo', osutils._win32_fixdrive('c:\\foo'))
305
def test_win98_abspath(self):
307
self.assertEqual('C:/foo', osutils._win98_abspath('C:\\foo'))
308
self.assertEqual('C:/foo', osutils._win98_abspath('C:/foo'))
310
self.assertEqual('//HOST/path', osutils._win98_abspath(r'\\HOST\path'))
311
self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
313
cwd = osutils.getcwd().rstrip('/')
314
drive = osutils._nt_splitdrive(cwd)[0]
315
self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
316
self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
319
self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
322
class TestWin32FuncsDirs(TestCaseInTempDir):
323
"""Test win32 functions that create files."""
325
def test_getcwd(self):
326
if win32utils.winver == 'Windows 98':
327
raise TestSkipped('Windows 98 cannot handle unicode filenames')
328
# Make sure getcwd can handle unicode filenames
332
raise TestSkipped("Unable to create Unicode filename")
335
# TODO: jam 20060427 This will probably fail on Mac OSX because
336
# it will change the normalization of B\xe5gfors
337
# Consider using a different unicode character, or make
338
# osutils.getcwd() renormalize the path.
339
self.assertEndsWith(osutils._win32_getcwd(), u'mu-\xb5')
341
def test_mkdtemp(self):
342
tmpdir = osutils._win32_mkdtemp(dir='.')
343
self.assertFalse('\\' in tmpdir)
345
def test_rename(self):
353
osutils._win32_rename('b', 'a')
354
self.failUnlessExists('a')
355
self.failIfExists('b')
356
self.assertFileEqual('baz\n', 'a')
358
def test_rename_missing_file(self):
364
osutils._win32_rename('b', 'a')
365
except (IOError, OSError), e:
366
self.assertEqual(errno.ENOENT, e.errno)
367
self.assertFileEqual('foo\n', 'a')
369
def test_rename_missing_dir(self):
372
osutils._win32_rename('b', 'a')
373
except (IOError, OSError), e:
374
self.assertEqual(errno.ENOENT, e.errno)
376
def test_rename_current_dir(self):
379
# You can't rename the working directory
380
# doing rename non-existant . usually
381
# just raises ENOENT, since non-existant
384
osutils._win32_rename('b', '.')
385
except (IOError, OSError), e:
386
self.assertEqual(errno.ENOENT, e.errno)
388
def test_splitpath(self):
389
def check(expected, path):
390
self.assertEqual(expected, osutils.splitpath(path))
393
check(['a', 'b'], 'a/b')
394
check(['a', 'b'], 'a/./b')
395
check(['a', '.b'], 'a/.b')
396
check(['a', '.b'], 'a\\.b')
398
self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
401
class TestMacFuncsDirs(TestCaseInTempDir):
402
"""Test mac special functions that require directories."""
404
def test_getcwd(self):
405
# On Mac, this will actually create Ba\u030agfors
406
# but chdir will still work, because it accepts both paths
408
os.mkdir(u'B\xe5gfors')
410
raise TestSkipped("Unable to create Unicode filename")
412
os.chdir(u'B\xe5gfors')
413
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
415
def test_getcwd_nonnorm(self):
416
# Test that _mac_getcwd() will normalize this path
418
os.mkdir(u'Ba\u030agfors')
420
raise TestSkipped("Unable to create Unicode filename")
422
os.chdir(u'Ba\u030agfors')
423
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
426
class TestSplitLines(TestCase):
428
def test_split_unicode(self):
429
self.assertEqual([u'foo\n', u'bar\xae'],
430
osutils.split_lines(u'foo\nbar\xae'))
431
self.assertEqual([u'foo\n', u'bar\xae\n'],
432
osutils.split_lines(u'foo\nbar\xae\n'))
434
def test_split_with_carriage_returns(self):
435
self.assertEqual(['foo\rbar\n'],
436
osutils.split_lines('foo\rbar\n'))
439
class TestWalkDirs(TestCaseInTempDir):
441
def test_walkdirs(self):
450
self.build_tree(tree)
451
expected_dirblocks = [
453
[('0file', '0file', 'file'),
454
('1dir', '1dir', 'directory'),
455
('2file', '2file', 'file'),
459
[('1dir/0file', '0file', 'file'),
460
('1dir/1dir', '1dir', 'directory'),
463
(('1dir/1dir', './1dir/1dir'),
470
for dirdetail, dirblock in osutils.walkdirs('.'):
471
if len(dirblock) and dirblock[0][1] == '.bzr':
472
# this tests the filtering of selected paths
475
result.append((dirdetail, dirblock))
477
self.assertTrue(found_bzrdir)
478
self.assertEqual(expected_dirblocks,
479
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
480
# you can search a subdir only, with a supplied prefix.
482
for dirblock in osutils.walkdirs('./1dir', '1dir'):
483
result.append(dirblock)
484
self.assertEqual(expected_dirblocks[1:],
485
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
487
def assertPathCompare(self, path_less, path_greater):
488
"""check that path_less and path_greater compare correctly."""
489
self.assertEqual(0, osutils.compare_paths_prefix_order(
490
path_less, path_less))
491
self.assertEqual(0, osutils.compare_paths_prefix_order(
492
path_greater, path_greater))
493
self.assertEqual(-1, osutils.compare_paths_prefix_order(
494
path_less, path_greater))
495
self.assertEqual(1, osutils.compare_paths_prefix_order(
496
path_greater, path_less))
498
def test_compare_paths_prefix_order(self):
499
# root before all else
500
self.assertPathCompare("/", "/a")
502
self.assertPathCompare("/a", "/b")
503
self.assertPathCompare("/b", "/z")
504
# high dirs before lower.
505
self.assertPathCompare("/z", "/a/a")
506
# except if the deeper dir should be output first
507
self.assertPathCompare("/a/b/c", "/d/g")
508
# lexical betwen dirs of the same height
509
self.assertPathCompare("/a/z", "/z/z")
510
self.assertPathCompare("/a/c/z", "/a/d/e")
512
# this should also be consistent for no leading / paths
513
# root before all else
514
self.assertPathCompare("", "a")
516
self.assertPathCompare("a", "b")
517
self.assertPathCompare("b", "z")
518
# high dirs before lower.
519
self.assertPathCompare("z", "a/a")
520
# except if the deeper dir should be output first
521
self.assertPathCompare("a/b/c", "d/g")
522
# lexical betwen dirs of the same height
523
self.assertPathCompare("a/z", "z/z")
524
self.assertPathCompare("a/c/z", "a/d/e")
526
def test_path_prefix_sorting(self):
527
"""Doing a sort on path prefix should match our sample data."""
558
sorted(original_paths, key=osutils.path_prefix_key))
559
# using the comparison routine shoudl work too:
562
sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
565
class TestCopyTree(TestCaseInTempDir):
567
def test_copy_basic_tree(self):
568
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
569
osutils.copy_tree('source', 'target')
570
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
571
self.assertEqual(['c'], os.listdir('target/b'))
573
def test_copy_tree_target_exists(self):
574
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c',
576
osutils.copy_tree('source', 'target')
577
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
578
self.assertEqual(['c'], os.listdir('target/b'))
580
def test_copy_tree_symlinks(self):
581
if not osutils.has_symlinks():
583
self.build_tree(['source/'])
584
os.symlink('a/generic/path', 'source/lnk')
585
osutils.copy_tree('source', 'target')
586
self.assertEqual(['lnk'], os.listdir('target'))
587
self.assertEqual('a/generic/path', os.readlink('target/lnk'))
589
def test_copy_tree_handlers(self):
592
def file_handler(from_path, to_path):
593
processed_files.append(('f', from_path, to_path))
594
def dir_handler(from_path, to_path):
595
processed_files.append(('d', from_path, to_path))
596
def link_handler(from_path, to_path):
597
processed_links.append((from_path, to_path))
598
handlers = {'file':file_handler,
599
'directory':dir_handler,
600
'symlink':link_handler,
603
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
604
if osutils.has_symlinks():
605
os.symlink('a/generic/path', 'source/lnk')
606
osutils.copy_tree('source', 'target', handlers=handlers)
608
self.assertEqual([('d', 'source', 'target'),
609
('f', 'source/a', 'target/a'),
610
('d', 'source/b', 'target/b'),
611
('f', 'source/b/c', 'target/b/c'),
613
self.failIfExists('target')
614
if osutils.has_symlinks():
615
self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
618
#class TestTerminalEncoding has been moved to test_osutils_encodings.py
619
# [bialix] 2006/12/26
622
class TestSetUnsetEnv(TestCase):
623
"""Test updating the environment"""
626
super(TestSetUnsetEnv, self).setUp()
628
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
629
'Environment was not cleaned up properly.'
630
' Variable BZR_TEST_ENV_VAR should not exist.')
632
if 'BZR_TEST_ENV_VAR' in os.environ:
633
del os.environ['BZR_TEST_ENV_VAR']
635
self.addCleanup(cleanup)
638
"""Test that we can set an env variable"""
639
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
640
self.assertEqual(None, old)
641
self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
643
def test_double_set(self):
644
"""Test that we get the old value out"""
645
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
646
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
647
self.assertEqual('foo', old)
648
self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
650
def test_unicode(self):
651
"""Environment can only contain plain strings
653
So Unicode strings must be encoded.
655
# Try a few different characters, to see if we can get
656
# one that will be valid in the user_encoding
657
possible_vals = [u'm\xb5', u'\xe1', u'\u0410']
658
for uni_val in possible_vals:
660
env_val = uni_val.encode(bzrlib.user_encoding)
661
except UnicodeEncodeError:
662
# Try a different character
667
raise TestSkipped('Cannot find a unicode character that works in'
668
' encoding %s' % (bzrlib.user_encoding,))
670
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
671
self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
673
def test_unset(self):
674
"""Test that passing None will remove the env var"""
675
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
676
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
677
self.assertEqual('foo', old)
678
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
679
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
682
class TestLocalTimeOffset(TestCase):
684
def test_local_time_offset(self):
685
"""Test that local_time_offset() returns a sane value."""
686
offset = osutils.local_time_offset()
687
self.assertTrue(isinstance(offset, int))
688
# Test that the offset is no more than a eighteen hours in
690
# Time zone handling is system specific, so it is difficult to
691
# do more specific tests, but a value outside of this range is
693
eighteen_hours = 18 * 3600
694
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
696
def test_local_time_offset_with_timestamp(self):
697
"""Test that local_time_offset() works with a timestamp."""
698
offset = osutils.local_time_offset(1000000000.1234567)
699
self.assertTrue(isinstance(offset, int))
700
eighteen_hours = 18 * 3600
701
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
added
removed
bzrlib/tests/test_osutils.py
