70
59
self.check_file_contents('a', 'something in a\n')
72
62
# TODO: test fancy_rename using a MemoryTransport
74
def test_01_rand_chars_empty(self):
75
result = osutils.rand_chars(0)
76
self.assertEqual(result, '')
78
def test_02_rand_chars_100(self):
79
result = osutils.rand_chars(100)
80
self.assertEqual(len(result), 100)
81
self.assertEqual(type(result), str)
82
self.assertContainsRe(result, r'^[a-z0-9]{100}$')
84
def test_is_inside(self):
85
is_inside = osutils.is_inside
86
self.assertTrue(is_inside('src', 'src/foo.c'))
87
self.assertFalse(is_inside('src', 'srccontrol'))
88
self.assertTrue(is_inside('src', 'src/a/a/a/foo.c'))
89
self.assertTrue(is_inside('foo.c', 'foo.c'))
90
self.assertFalse(is_inside('foo.c', ''))
91
self.assertTrue(is_inside('', 'foo.c'))
93
def test_rmtree(self):
94
# Check to remove tree with read-only files/dirs
96
f = file('dir/file', 'w')
99
# would like to also try making the directory readonly, but at the
100
# moment python shutil.rmtree doesn't handle that properly - it would
101
# need to chmod the directory before removing things inside it - deferred
102
# for now -- mbp 20060505
103
# osutils.make_readonly('dir')
104
osutils.make_readonly('dir/file')
106
osutils.rmtree('dir')
108
self.failIfExists('dir/file')
109
self.failIfExists('dir')
111
def test_file_kind(self):
112
self.build_tree(['file', 'dir/'])
113
self.assertEquals('file', osutils.file_kind('file'))
114
self.assertEquals('directory', osutils.file_kind('dir/'))
115
if osutils.has_symlinks():
116
os.symlink('symlink', 'symlink')
117
self.assertEquals('symlink', osutils.file_kind('symlink'))
119
# TODO: jam 20060529 Test a block device
121
os.lstat('/dev/null')
123
if e.errno not in (errno.ENOENT,):
126
self.assertEquals('chardev', osutils.file_kind('/dev/null'))
128
mkfifo = getattr(os, 'mkfifo', None)
132
self.assertEquals('fifo', osutils.file_kind('fifo'))
136
AF_UNIX = getattr(socket, 'AF_UNIX', None)
138
s = socket.socket(AF_UNIX)
141
self.assertEquals('socket', osutils.file_kind('socket'))
145
def test_get_umask(self):
146
if sys.platform == 'win32':
147
# umask always returns '0', no way to set it
148
self.assertEqual(0, osutils.get_umask())
151
orig_umask = osutils.get_umask()
154
self.assertEqual(0222, osutils.get_umask())
156
self.assertEqual(0022, osutils.get_umask())
158
self.assertEqual(0002, osutils.get_umask())
160
self.assertEqual(0027, osutils.get_umask())
164
def assertFormatedDelta(self, expected, seconds):
165
"""Assert osutils.format_delta formats as expected"""
166
actual = osutils.format_delta(seconds)
167
self.assertEqual(expected, actual)
169
def test_format_delta(self):
170
self.assertFormatedDelta('0 seconds ago', 0)
171
self.assertFormatedDelta('1 second ago', 1)
172
self.assertFormatedDelta('10 seconds ago', 10)
173
self.assertFormatedDelta('59 seconds ago', 59)
174
self.assertFormatedDelta('89 seconds ago', 89)
175
self.assertFormatedDelta('1 minute, 30 seconds ago', 90)
176
self.assertFormatedDelta('3 minutes, 0 seconds ago', 180)
177
self.assertFormatedDelta('3 minutes, 1 second ago', 181)
178
self.assertFormatedDelta('10 minutes, 15 seconds ago', 615)
179
self.assertFormatedDelta('30 minutes, 59 seconds ago', 1859)
180
self.assertFormatedDelta('31 minutes, 0 seconds ago', 1860)
181
self.assertFormatedDelta('60 minutes, 0 seconds ago', 3600)
182
self.assertFormatedDelta('89 minutes, 59 seconds ago', 5399)
183
self.assertFormatedDelta('1 hour, 30 minutes ago', 5400)
184
self.assertFormatedDelta('2 hours, 30 minutes ago', 9017)
185
self.assertFormatedDelta('10 hours, 0 minutes ago', 36000)
186
self.assertFormatedDelta('24 hours, 0 minutes ago', 86400)
187
self.assertFormatedDelta('35 hours, 59 minutes ago', 129599)
188
self.assertFormatedDelta('36 hours, 0 minutes ago', 129600)
189
self.assertFormatedDelta('36 hours, 0 minutes ago', 129601)
190
self.assertFormatedDelta('36 hours, 1 minute ago', 129660)
191
self.assertFormatedDelta('36 hours, 1 minute ago', 129661)
192
self.assertFormatedDelta('84 hours, 10 minutes ago', 303002)
194
# We handle when time steps the wrong direction because computers
195
# don't have synchronized clocks.
196
self.assertFormatedDelta('84 hours, 10 minutes in the future', -303002)
197
self.assertFormatedDelta('1 second in the future', -1)
198
self.assertFormatedDelta('2 seconds in the future', -2)
200
def test_dereference_path(self):
201
if not osutils.has_symlinks():
202
raise TestSkipped('Symlinks are not supported on this platform')
203
cwd = osutils.realpath('.')
205
bar_path = osutils.pathjoin(cwd, 'bar')
206
# Using './' to avoid bug #1213894 (first path component not
207
# dereferenced) in Python 2.4.1 and earlier
208
self.assertEqual(bar_path, osutils.realpath('./bar'))
209
os.symlink('bar', 'foo')
210
self.assertEqual(bar_path, osutils.realpath('./foo'))
212
# Does not dereference terminal symlinks
213
foo_path = osutils.pathjoin(cwd, 'foo')
214
self.assertEqual(foo_path, osutils.dereference_path('./foo'))
216
# Dereferences parent symlinks
218
baz_path = osutils.pathjoin(bar_path, 'baz')
219
self.assertEqual(baz_path, osutils.dereference_path('./foo/baz'))
221
# Dereferences parent symlinks that are the first path element
222
self.assertEqual(baz_path, osutils.dereference_path('foo/baz'))
224
# Dereferences parent symlinks in absolute paths
225
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
226
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
229
class TestSafeUnicode(TestCase):
231
def test_from_ascii_string(self):
232
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
234
def test_from_unicode_string_ascii_contents(self):
235
self.assertEqual(u'bargam', osutils.safe_unicode(u'bargam'))
237
def test_from_unicode_string_unicode_contents(self):
238
self.assertEqual(u'bargam\xae', osutils.safe_unicode(u'bargam\xae'))
240
def test_from_utf8_string(self):
241
self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
243
def test_bad_utf8_string(self):
244
self.assertRaises(BzrBadParameterNotUnicode,
245
osutils.safe_unicode,
249
class TestWin32Funcs(TestCase):
250
"""Test that the _win32 versions of os utilities return appropriate paths."""
252
def test_abspath(self):
253
self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
254
self.assertEqual('C:/foo', osutils._win32_abspath('C:/foo'))
256
def test_realpath(self):
257
self.assertEqual('C:/foo', osutils._win32_realpath('C:\\foo'))
258
self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
260
def test_pathjoin(self):
261
self.assertEqual('path/to/foo', osutils._win32_pathjoin('path', 'to', 'foo'))
262
self.assertEqual('C:/foo', osutils._win32_pathjoin('path\\to', 'C:\\foo'))
263
self.assertEqual('C:/foo', osutils._win32_pathjoin('path/to', 'C:/foo'))
264
self.assertEqual('path/to/foo', osutils._win32_pathjoin('path/to/', 'foo'))
265
self.assertEqual('/foo', osutils._win32_pathjoin('C:/path/to/', '/foo'))
266
self.assertEqual('/foo', osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
268
def test_normpath(self):
269
self.assertEqual('path/to/foo', osutils._win32_normpath(r'path\\from\..\to\.\foo'))
270
self.assertEqual('path/to/foo', osutils._win32_normpath('path//from/../to/./foo'))
272
def test_getcwd(self):
273
cwd = osutils._win32_getcwd()
274
os_cwd = os.getcwdu()
275
self.assertEqual(os_cwd[1:].replace('\\', '/'), cwd[1:])
276
# win32 is inconsistent whether it returns lower or upper case
277
# and even if it was consistent the user might type the other
278
# so we force it to uppercase
279
# running python.exe under cmd.exe return capital C:\\
280
# running win32 python inside a cygwin shell returns lowercase
281
self.assertEqual(os_cwd[0].upper(), cwd[0])
283
def test_fixdrive(self):
284
self.assertEqual('H:/foo', osutils._win32_fixdrive('h:/foo'))
285
self.assertEqual('H:/foo', osutils._win32_fixdrive('H:/foo'))
286
self.assertEqual('C:\\foo', osutils._win32_fixdrive('c:\\foo'))
289
class TestWin32FuncsDirs(TestCaseInTempDir):
290
"""Test win32 functions that create files."""
292
def test_getcwd(self):
293
# Make sure getcwd can handle unicode filenames
297
raise TestSkipped("Unable to create Unicode filename")
300
# TODO: jam 20060427 This will probably fail on Mac OSX because
301
# it will change the normalization of B\xe5gfors
302
# Consider using a different unicode character, or make
303
# osutils.getcwd() renormalize the path.
304
self.assertEndsWith(osutils._win32_getcwd(), u'mu-\xb5')
306
def test_mkdtemp(self):
307
tmpdir = osutils._win32_mkdtemp(dir='.')
308
self.assertFalse('\\' in tmpdir)
310
def test_rename(self):
318
osutils._win32_rename('b', 'a')
319
self.failUnlessExists('a')
320
self.failIfExists('b')
321
self.assertFileEqual('baz\n', 'a')
323
def test_rename_missing_file(self):
329
osutils._win32_rename('b', 'a')
330
except (IOError, OSError), e:
331
self.assertEqual(errno.ENOENT, e.errno)
332
self.assertFileEqual('foo\n', 'a')
334
def test_rename_missing_dir(self):
337
osutils._win32_rename('b', 'a')
338
except (IOError, OSError), e:
339
self.assertEqual(errno.ENOENT, e.errno)
341
def test_rename_current_dir(self):
344
# You can't rename the working directory
345
# doing rename non-existant . usually
346
# just raises ENOENT, since non-existant
349
osutils._win32_rename('b', '.')
350
except (IOError, OSError), e:
351
self.assertEqual(errno.ENOENT, e.errno)
353
def test_splitpath(self):
354
def check(expected, path):
355
self.assertEqual(expected, osutils.splitpath(path))
358
check(['a', 'b'], 'a/b')
359
check(['a', 'b'], 'a/./b')
360
check(['a', '.b'], 'a/.b')
361
check(['a', '.b'], 'a\\.b')
363
self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
366
class TestMacFuncsDirs(TestCaseInTempDir):
367
"""Test mac special functions that require directories."""
369
def test_getcwd(self):
370
# On Mac, this will actually create Ba\u030agfors
371
# but chdir will still work, because it accepts both paths
373
os.mkdir(u'B\xe5gfors')
375
raise TestSkipped("Unable to create Unicode filename")
377
os.chdir(u'B\xe5gfors')
378
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
380
def test_getcwd_nonnorm(self):
381
# Test that _mac_getcwd() will normalize this path
383
os.mkdir(u'Ba\u030agfors')
385
raise TestSkipped("Unable to create Unicode filename")
387
os.chdir(u'Ba\u030agfors')
388
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
391
class TestSplitLines(TestCase):
393
def test_split_unicode(self):
394
self.assertEqual([u'foo\n', u'bar\xae'],
395
osutils.split_lines(u'foo\nbar\xae'))
396
self.assertEqual([u'foo\n', u'bar\xae\n'],
397
osutils.split_lines(u'foo\nbar\xae\n'))
399
def test_split_with_carriage_returns(self):
400
self.assertEqual(['foo\rbar\n'],
401
osutils.split_lines('foo\rbar\n'))
404
class TestWalkDirs(TestCaseInTempDir):
406
def test_walkdirs(self):
415
self.build_tree(tree)
416
expected_dirblocks = [
418
[('0file', '0file', 'file'),
419
('1dir', '1dir', 'directory'),
420
('2file', '2file', 'file'),
424
[('1dir/0file', '0file', 'file'),
425
('1dir/1dir', '1dir', 'directory'),
428
(('1dir/1dir', './1dir/1dir'),
435
for dirdetail, dirblock in osutils.walkdirs('.'):
436
if len(dirblock) and dirblock[0][1] == '.bzr':
437
# this tests the filtering of selected paths
440
result.append((dirdetail, dirblock))
442
self.assertTrue(found_bzrdir)
443
self.assertEqual(expected_dirblocks,
444
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
445
# you can search a subdir only, with a supplied prefix.
447
for dirblock in osutils.walkdirs('./1dir', '1dir'):
448
result.append(dirblock)
449
self.assertEqual(expected_dirblocks[1:],
450
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
452
def assertPathCompare(self, path_less, path_greater):
453
"""check that path_less and path_greater compare correctly."""
454
self.assertEqual(0, osutils.compare_paths_prefix_order(
455
path_less, path_less))
456
self.assertEqual(0, osutils.compare_paths_prefix_order(
457
path_greater, path_greater))
458
self.assertEqual(-1, osutils.compare_paths_prefix_order(
459
path_less, path_greater))
460
self.assertEqual(1, osutils.compare_paths_prefix_order(
461
path_greater, path_less))
463
def test_compare_paths_prefix_order(self):
464
# root before all else
465
self.assertPathCompare("/", "/a")
467
self.assertPathCompare("/a", "/b")
468
self.assertPathCompare("/b", "/z")
469
# high dirs before lower.
470
self.assertPathCompare("/z", "/a/a")
471
# except if the deeper dir should be output first
472
self.assertPathCompare("/a/b/c", "/d/g")
473
# lexical betwen dirs of the same height
474
self.assertPathCompare("/a/z", "/z/z")
475
self.assertPathCompare("/a/c/z", "/a/d/e")
477
# this should also be consistent for no leading / paths
478
# root before all else
479
self.assertPathCompare("", "a")
481
self.assertPathCompare("a", "b")
482
self.assertPathCompare("b", "z")
483
# high dirs before lower.
484
self.assertPathCompare("z", "a/a")
485
# except if the deeper dir should be output first
486
self.assertPathCompare("a/b/c", "d/g")
487
# lexical betwen dirs of the same height
488
self.assertPathCompare("a/z", "z/z")
489
self.assertPathCompare("a/c/z", "a/d/e")
491
def test_path_prefix_sorting(self):
492
"""Doing a sort on path prefix should match our sample data."""
523
sorted(original_paths, key=osutils.path_prefix_key))
524
# using the comparison routine shoudl work too:
527
sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
530
class TestCopyTree(TestCaseInTempDir):
532
def test_copy_basic_tree(self):
533
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
534
osutils.copy_tree('source', 'target')
535
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
536
self.assertEqual(['c'], os.listdir('target/b'))
538
def test_copy_tree_target_exists(self):
539
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c',
541
osutils.copy_tree('source', 'target')
542
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
543
self.assertEqual(['c'], os.listdir('target/b'))
545
def test_copy_tree_symlinks(self):
546
if not osutils.has_symlinks():
548
self.build_tree(['source/'])
549
os.symlink('a/generic/path', 'source/lnk')
550
osutils.copy_tree('source', 'target')
551
self.assertEqual(['lnk'], os.listdir('target'))
552
self.assertEqual('a/generic/path', os.readlink('target/lnk'))
554
def test_copy_tree_handlers(self):
557
def file_handler(from_path, to_path):
558
processed_files.append(('f', from_path, to_path))
559
def dir_handler(from_path, to_path):
560
processed_files.append(('d', from_path, to_path))
561
def link_handler(from_path, to_path):
562
processed_links.append((from_path, to_path))
563
handlers = {'file':file_handler,
564
'directory':dir_handler,
565
'symlink':link_handler,
568
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
569
if osutils.has_symlinks():
570
os.symlink('a/generic/path', 'source/lnk')
571
osutils.copy_tree('source', 'target', handlers=handlers)
573
self.assertEqual([('d', 'source', 'target'),
574
('f', 'source/a', 'target/a'),
575
('d', 'source/b', 'target/b'),
576
('f', 'source/b/c', 'target/b/c'),
578
self.failIfExists('target')
579
if osutils.has_symlinks():
580
self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
583
#class TestTerminalEncoding has been moved to test_osutils_encodings.py
584
# [bialix] 2006/12/26
587
class TestSetUnsetEnv(TestCase):
588
"""Test updating the environment"""
591
super(TestSetUnsetEnv, self).setUp()
593
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
594
'Environment was not cleaned up properly.'
595
' Variable BZR_TEST_ENV_VAR should not exist.')
597
if 'BZR_TEST_ENV_VAR' in os.environ:
598
del os.environ['BZR_TEST_ENV_VAR']
600
self.addCleanup(cleanup)
603
"""Test that we can set an env variable"""
604
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
605
self.assertEqual(None, old)
606
self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
608
def test_double_set(self):
609
"""Test that we get the old value out"""
610
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
611
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
612
self.assertEqual('foo', old)
613
self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
615
def test_unicode(self):
616
"""Environment can only contain plain strings
618
So Unicode strings must be encoded.
620
# Try a few different characters, to see if we can get
621
# one that will be valid in the user_encoding
622
possible_vals = [u'm\xb5', u'\xe1', u'\u0410']
623
for uni_val in possible_vals:
625
env_val = uni_val.encode(bzrlib.user_encoding)
626
except UnicodeEncodeError:
627
# Try a different character
632
raise TestSkipped('Cannot find a unicode character that works in'
633
' encoding %s' % (bzrlib.user_encoding,))
635
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
636
self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
638
def test_unset(self):
639
"""Test that passing None will remove the env var"""
640
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
641
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
642
self.assertEqual('foo', old)
643
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
644
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
647
class TestLocalTimeOffset(TestCase):
649
def test_local_time_offset(self):
650
"""Test that local_time_offset() returns a sane value."""
651
offset = osutils.local_time_offset()
652
self.assertTrue(isinstance(offset, int))
653
# Test that the offset is no more than a eighteen hours in
655
# Time zone handling is system specific, so it is difficult to
656
# do more specific tests, but a value outside of this range is
658
eighteen_hours = 18 * 3600
659
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
661
def test_local_time_offset_with_timestamp(self):
662
"""Test that local_time_offset() works with a timestamp."""
663
offset = osutils.local_time_offset(1000000000.1234567)
664
self.assertTrue(isinstance(offset, int))
665
eighteen_hours = 18 * 3600
666
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
added
removed
bzrlib/tests/test_osutils.py
