← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

  • Committer: Jelmer Vernooij
  • Date: 2010-01-20 22:32:07 UTC
  • mto: This revision was merged to the branch mainline in revision 4977.
  • Revision ID: jelmer@samba.org-20100120223207-pfz89u161ahyzvnt
Add FileTimestampUnavailable exception.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2006-2012 Canonical Ltd
 
1
# Copyright (C) 2005 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
20
20
import sys
21
21
 
22
22
from bzrlib import osutils, urlutils, win32utils
23
 
from bzrlib.errors import (
24
 
    InvalidURL,
25
 
    InvalidURLJoin,
26
 
    InvalidRebaseURLs,
27
 
    PathNotChild,
28
 
    )
 
23
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
29
24
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
30
25
 
31
26
 
161
156
        # Weird stuff
162
157
        # Can't have slashes or colons in the scheme
163
158
        test_one('/path/to/://foo', None)
164
 
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
 
159
        test_one('path:path://foo', None)
165
160
        # Must have more than one character for scheme
166
161
        test_one('C://foo', None)
167
162
        test_one('ab://foo', ('ab', 'foo'))
200
195
            dirname('path/to/foo/', exclude_trailing_slash=False))
201
196
        self.assertEqual('path/..', dirname('path/../foo'))
202
197
        self.assertEqual('../path', dirname('../path/foo'))
203
 
    
204
 
    def test_is_url(self):
205
 
        self.assertTrue(urlutils.is_url('http://foo/bar'))
206
 
        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))
207
 
        self.assertTrue(urlutils.is_url('lp:foo/bar'))
208
 
        self.assertTrue(urlutils.is_url('file:///foo/bar'))
209
 
        self.assertFalse(urlutils.is_url(''))
210
 
        self.assertFalse(urlutils.is_url('foo'))
211
 
        self.assertFalse(urlutils.is_url('foo/bar'))
212
 
        self.assertFalse(urlutils.is_url('/foo'))
213
 
        self.assertFalse(urlutils.is_url('/foo/bar'))
214
 
        self.assertFalse(urlutils.is_url('C:/'))
215
 
        self.assertFalse(urlutils.is_url('C:/foo'))
216
 
        self.assertFalse(urlutils.is_url('C:/foo/bar'))
217
198
 
218
199
    def test_join(self):
219
200
        def test(expected, *args):
229
210
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
230
211
        test('http://foo/baz', 'http://foo', 'bar/../baz')
231
212
        test('http://foo/baz', 'http://foo/bar/', '../baz')
232
 
        test('lp:foo/bar', 'lp:foo', 'bar')
233
 
        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')
234
213
 
235
214
        # Absolute paths
236
215
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
240
219
        test('http://bar/', 'http://foo', 'http://bar/')
241
220
        test('http://bar/a', 'http://foo', 'http://bar/a')
242
221
        test('http://bar/a/', 'http://foo', 'http://bar/a/')
243
 
        test('lp:bar', 'http://foo', 'lp:bar')
244
 
        test('lp:bar', 'lp:foo', 'lp:bar')
245
 
        test('file:///stuff', 'lp:foo', 'file:///stuff')
246
222
 
247
223
        # From a base path
248
224
        test('file:///foo', 'file:///', 'foo')
294
270
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
295
271
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
296
272
 
297
 
    def test_join_segment_parameters_raw(self):
298
 
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
299
 
        self.assertEquals("/somedir/path", 
300
 
            join_segment_parameters_raw("/somedir/path"))
301
 
        self.assertEquals("/somedir/path,rawdata", 
302
 
            join_segment_parameters_raw("/somedir/path", "rawdata"))
303
 
        self.assertRaises(InvalidURLJoin,
304
 
            join_segment_parameters_raw, "/somedir/path",
305
 
                "rawdata1,rawdata2,rawdata3")
306
 
        self.assertEquals("/somedir/path,bla,bar",
307
 
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
308
 
        self.assertEquals("/somedir,exist=some/path,bla,bar",
309
 
            join_segment_parameters_raw("/somedir,exist=some/path",
310
 
                "bla", "bar"))
311
 
        self.assertRaises(TypeError, join_segment_parameters_raw, 
312
 
            "/somepath", 42)
313
 
 
314
 
    def test_join_segment_parameters(self):
315
 
        join_segment_parameters = urlutils.join_segment_parameters
316
 
        self.assertEquals("/somedir/path", 
317
 
            join_segment_parameters("/somedir/path", {}))
318
 
        self.assertEquals("/somedir/path,key1=val1", 
319
 
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
320
 
        self.assertRaises(InvalidURLJoin,
321
 
            join_segment_parameters, "/somedir/path",
322
 
            {"branch": "brr,brr,brr"})
323
 
        self.assertRaises(InvalidURLJoin,
324
 
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
325
 
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
326
 
            join_segment_parameters("/somedir/path", {
327
 
                "key1": "val1", "key2": "val2"}))
328
 
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
329
 
            join_segment_parameters("/somedir/path,key1=val1", {
330
 
                "key2": "val2"}))
331
 
        self.assertEquals("/somedir/path,key1=val2",
332
 
            join_segment_parameters("/somedir/path,key1=val1", {
333
 
                "key1": "val2"}))
334
 
        self.assertEquals("/somedir,exist=some/path,key1=val1",
335
 
            join_segment_parameters("/somedir,exist=some/path",
336
 
                {"key1": "val1"}))
337
 
        self.assertEquals("/,key1=val1,key2=val2",
338
 
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
339
 
        self.assertRaises(TypeError,
340
 
            join_segment_parameters, "/,key1=val1", {"foo": 42})
341
 
 
342
273
    def test_function_type(self):
343
274
        if sys.platform == 'win32':
344
 
            self.assertEqual(urlutils._win32_local_path_to_url,
345
 
                urlutils.local_path_to_url)
346
 
            self.assertEqual(urlutils._win32_local_path_from_url,
347
 
                urlutils.local_path_from_url)
 
275
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
 
276
            self.assertEqual(urlutils._win32_local_path_from_url, urlutils.local_path_from_url)
348
277
        else:
349
 
            self.assertEqual(urlutils._posix_local_path_to_url,
350
 
                urlutils.local_path_to_url)
351
 
            self.assertEqual(urlutils._posix_local_path_from_url,
352
 
                urlutils.local_path_from_url)
 
278
            self.assertEqual(urlutils._posix_local_path_to_url, urlutils.local_path_to_url)
 
279
            self.assertEqual(urlutils._posix_local_path_from_url, urlutils.local_path_from_url)
353
280
 
354
281
    def test_posix_local_path_to_url(self):
355
282
        to_url = urlutils._posix_local_path_to_url
356
283
        self.assertEqual('file:///path/to/foo',
357
284
            to_url('/path/to/foo'))
358
285
 
359
 
        self.assertEqual('file:///path/to/foo%2Cbar',
360
 
            to_url('/path/to/foo,bar'))
361
 
 
362
286
        try:
363
287
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
364
288
        except UnicodeError:
371
295
        from_url = urlutils._posix_local_path_from_url
372
296
        self.assertEqual('/path/to/foo',
373
297
            from_url('file:///path/to/foo'))
374
 
        self.assertEqual('/path/to/foo',
375
 
            from_url('file:///path/to/foo,branch=foo'))
376
298
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
377
299
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
378
300
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
400
322
 
401
323
        self.assertEqual('file:///', to_url('/'))
402
324
 
403
 
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
404
 
            to_url('C:/path/to/foo,bar'))
405
325
        try:
406
326
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
407
327
        except UnicodeError:
434
354
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
435
355
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
436
356
        self.assertEqual('/', from_url('file:///'))
437
 
        self.assertEqual('C:/path/to/foo',
438
 
            from_url('file:///C|/path/to/foo,branch=foo'))
439
357
 
440
 
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
441
 
        self.assertRaises(InvalidURL, from_url, 'file:///c')
442
358
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
443
359
        # Not a valid _win32 url, no drive letter
444
360
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
446
362
    def test_win32_unc_path_from_url(self):
447
363
        from_url = urlutils._win32_local_path_from_url
448
364
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
449
 
        self.assertEqual('//HOST/path',
450
 
            from_url('file://HOST/path,branch=foo'))
451
365
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
452
366
        # we want to use only 2 slashes
453
367
        # Firefox understand only 5 slashes in URL, but it's ugly
462
376
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
463
377
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
464
378
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
465
 
        # Root drives without slash treated as invalid, see bug #841322
466
 
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
467
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C:')
468
 
        # Invalid without drive separator or following forward slash
469
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C')
470
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C:ool')
471
379
 
472
380
    def test_split(self):
473
381
        # Test bzrlib.urlutils.split()
504
412
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
505
413
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
506
414
 
507
 
    def test_split_segment_parameters_raw(self):
508
 
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
509
 
        # Check relative references with absolute paths
510
 
        self.assertEquals(("/some/path", []),
511
 
            split_segment_parameters_raw("/some/path"))
512
 
        self.assertEquals(("/some/path", ["tip"]),
513
 
            split_segment_parameters_raw("/some/path,tip"))
514
 
        self.assertEquals(("/some,dir/path", ["tip"]),
515
 
            split_segment_parameters_raw("/some,dir/path,tip"))
516
 
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
517
 
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
518
 
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
519
 
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
520
 
        # Check relative references with relative paths
521
 
        self.assertEquals(("", ["key1=val1"]),
522
 
            split_segment_parameters_raw(",key1=val1"))
523
 
        self.assertEquals(("foo/", ["key1=val1"]),
524
 
            split_segment_parameters_raw("foo/,key1=val1"))
525
 
        self.assertEquals(("foo", ["key1=val1"]),
526
 
            split_segment_parameters_raw("foo,key1=val1"))
527
 
        self.assertEquals(("foo/base,la=bla/other/elements", []),
528
 
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
529
 
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
530
 
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
531
 
        # TODO: Check full URLs as well as relative references
532
 
 
533
 
    def test_split_segment_parameters(self):
534
 
        split_segment_parameters = urlutils.split_segment_parameters
535
 
        # Check relative references with absolute paths
536
 
        self.assertEquals(("/some/path", {}),
537
 
            split_segment_parameters("/some/path"))
538
 
        self.assertEquals(("/some/path", {"branch": "tip"}),
539
 
            split_segment_parameters("/some/path,branch=tip"))
540
 
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
541
 
            split_segment_parameters("/some,dir/path,branch=tip"))
542
 
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
543
 
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
544
 
        self.assertEquals(("/somedir/path",
545
 
            {"ref": "heads%2Ftip", "key1": "val1"}),
546
 
            split_segment_parameters(
547
 
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
548
 
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
549
 
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
550
 
        # Check relative references with relative paths
551
 
        self.assertEquals(("", {"key1": "val1"}),
552
 
            split_segment_parameters(",key1=val1"))
553
 
        self.assertEquals(("foo/", {"key1": "val1"}),
554
 
            split_segment_parameters("foo/,key1=val1"))
555
 
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
556
 
            split_segment_parameters("foo/base,key1=val1/other/elements"))
557
 
        self.assertEquals(("foo/base,key1=val1/other/elements",
558
 
            {"key2": "val2"}), split_segment_parameters(
559
 
                "foo/base,key1=val1/other/elements,key2=val2"))
560
 
        # TODO: Check full URLs as well as relative references
561
 
 
562
415
    def test_win32_strip_local_trailing_slash(self):
563
416
        strip = urlutils._win32_strip_local_trailing_slash
564
417
        self.assertEqual('file://', strip('file://'))
725
578
 
726
579
 
727
580
class TestCwdToURL(TestCaseInTempDir):
728
 
    """Test that local_path_to_url works based on the cwd"""
 
581
    """Test that local_path_to_url works base on the cwd"""
729
582
 
730
583
    def test_dot(self):
731
584
        # This test will fail if getcwd is not ascii
827
680
 
828
681
class TestParseURL(TestCase):
829
682
 
830
 
    def test_parse_simple(self):
831
 
        parsed = urlutils.parse_url('http://example.com:80/one')
832
 
        self.assertEquals(('http', None, None, 'example.com', 80, '/one'),
833
 
            parsed)
834
 
 
835
 
    def test_ipv6(self):
836
 
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
837
 
        self.assertEquals(('http', None, None, '1:2:3::40', None, '/one'),
838
 
            parsed)
839
 
 
840
 
    def test_ipv6_port(self):
841
 
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
842
 
        self.assertEquals(('http', None, None, '1:2:3::40', 80, '/one'),
843
 
            parsed)
844
 
 
845
 
 
846
 
class TestURL(TestCase):
847
 
 
848
 
    def test_parse_simple(self):
849
 
        parsed = urlutils.URL.from_string('http://example.com:80/one')
850
 
        self.assertEquals('http', parsed.scheme)
851
 
        self.assertIs(None, parsed.user)
852
 
        self.assertIs(None, parsed.password)
853
 
        self.assertEquals('example.com', parsed.host)
854
 
        self.assertEquals(80, parsed.port)
855
 
        self.assertEquals('/one', parsed.path)
856
 
 
857
 
    def test_ipv6(self):
858
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
859
 
        self.assertEquals('http', parsed.scheme)
860
 
        self.assertIs(None, parsed.port)
861
 
        self.assertIs(None, parsed.user)
862
 
        self.assertIs(None, parsed.password)
863
 
        self.assertEquals('1:2:3::40', parsed.host)
864
 
        self.assertEquals('/one', parsed.path)
865
 
 
866
 
    def test_ipv6_port(self):
867
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
868
 
        self.assertEquals('http', parsed.scheme)
869
 
        self.assertEquals('1:2:3::40', parsed.host)
870
 
        self.assertIs(None, parsed.user)
871
 
        self.assertIs(None, parsed.password)
872
 
        self.assertEquals(80, parsed.port)
873
 
        self.assertEquals('/one', parsed.path)
874
 
 
875
 
    def test_quoted(self):
876
 
        parsed = urlutils.URL.from_string(
877
 
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
878
 
        self.assertEquals(parsed.quoted_host, 'ex%41mple.com')
879
 
        self.assertEquals(parsed.host, 'exAmple.com')
880
 
        self.assertEquals(parsed.port, 2222)
881
 
        self.assertEquals(parsed.quoted_user, 'ro%62ey')
882
 
        self.assertEquals(parsed.user, 'robey')
883
 
        self.assertEquals(parsed.quoted_password, 'h%40t')
884
 
        self.assertEquals(parsed.password, 'h@t')
885
 
        self.assertEquals(parsed.path, '/path')
886
 
 
887
 
    def test_eq(self):
888
 
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
889
 
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
890
 
        self.assertEquals(parsed1, parsed2)
891
 
        self.assertEquals(parsed1, parsed1)
892
 
        parsed2.path = '/two'
893
 
        self.assertNotEquals(parsed1, parsed2)
894
 
 
895
 
    def test_repr(self):
896
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
897
 
        self.assertEquals(
898
 
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
899
 
            repr(parsed))
900
 
 
901
 
    def test_str(self):
902
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
903
 
        self.assertEquals('http://[1:2:3::40]:80/one', str(parsed))
904
 
 
905
 
    def test__combine_paths(self):
906
 
        combine = urlutils.URL._combine_paths
907
 
        self.assertEqual('/home/sarah/project/foo',
908
 
                         combine('/home/sarah', 'project/foo'))
909
 
        self.assertEqual('/etc',
910
 
                         combine('/home/sarah', '../../etc'))
911
 
        self.assertEqual('/etc',
912
 
                         combine('/home/sarah', '../../../etc'))
913
 
        self.assertEqual('/etc',
914
 
                         combine('/home/sarah', '/etc'))
915
 
 
916
 
    def test_clone(self):
917
 
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
918
 
        url1 = url.clone("two")
919
 
        self.assertEquals("/one/two", url1.path)
920
 
        url2 = url.clone("/two")
921
 
        self.assertEquals("/two", url2.path)
922
 
        url3 = url.clone()
923
 
        self.assertIsNot(url, url3)
924
 
        self.assertEquals(url, url3)
925
 
 
926
 
 
927
 
class TestFileRelpath(TestCase):
928
 
 
929
 
    # GZ 2011-11-18: A way to override all path handling functions to one
930
 
    #                platform or another for testing would be nice.
931
 
 
932
 
    def _with_posix_paths(self):
933
 
        self.overrideAttr(urlutils, "local_path_from_url",
934
 
            urlutils._posix_local_path_from_url)
935
 
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH", len("file:///"))
936
 
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
937
 
        self.overrideAttr(osutils, "abspath", osutils._posix_abspath)
938
 
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
939
 
        self.overrideAttr(osutils, "pathjoin", osutils.posixpath.join)
940
 
        self.overrideAttr(osutils, "split", osutils.posixpath.split)
941
 
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 1)
942
 
 
943
 
    def _with_win32_paths(self):
944
 
        self.overrideAttr(urlutils, "local_path_from_url",
945
 
            urlutils._win32_local_path_from_url)
946
 
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH",
947
 
            urlutils.WIN32_MIN_ABS_FILEURL_LENGTH)
948
 
        self.overrideAttr(osutils, "abspath", osutils._win32_abspath)
949
 
        self.overrideAttr(osutils, "normpath", osutils._win32_normpath)
950
 
        self.overrideAttr(osutils, "pathjoin", osutils._win32_pathjoin)
951
 
        self.overrideAttr(osutils, "split", osutils.ntpath.split)
952
 
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 3)
953
 
 
954
 
    def test_same_url_posix(self):
955
 
        self._with_posix_paths()
956
 
        self.assertEquals("",
957
 
            urlutils.file_relpath("file:///a", "file:///a"))
958
 
        self.assertEquals("",
959
 
            urlutils.file_relpath("file:///a", "file:///a/"))
960
 
        self.assertEquals("",
961
 
            urlutils.file_relpath("file:///a/", "file:///a"))
962
 
 
963
 
    def test_same_url_win32(self):
964
 
        self._with_win32_paths()
965
 
        self.assertEquals("",
966
 
            urlutils.file_relpath("file:///A:/", "file:///A:/"))
967
 
        self.assertEquals("",
968
 
            urlutils.file_relpath("file:///A|/", "file:///A:/"))
969
 
        self.assertEquals("",
970
 
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
971
 
        self.assertEquals("",
972
 
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
973
 
        self.assertEquals("",
974
 
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
975
 
 
976
 
    def test_child_posix(self):
977
 
        self._with_posix_paths()
978
 
        self.assertEquals("b",
979
 
            urlutils.file_relpath("file:///a", "file:///a/b"))
980
 
        self.assertEquals("b",
981
 
            urlutils.file_relpath("file:///a/", "file:///a/b"))
982
 
        self.assertEquals("b/c",
983
 
            urlutils.file_relpath("file:///a", "file:///a/b/c"))
984
 
 
985
 
    def test_child_win32(self):
986
 
        self._with_win32_paths()
987
 
        self.assertEquals("b",
988
 
            urlutils.file_relpath("file:///A:/", "file:///A:/b"))
989
 
        self.assertEquals("b",
990
 
            urlutils.file_relpath("file:///A|/", "file:///A:/b"))
991
 
        self.assertEquals("c",
992
 
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
993
 
        self.assertEquals("c",
994
 
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
995
 
        self.assertEquals("c/d",
996
 
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
997
 
 
998
 
    def test_sibling_posix(self):
999
 
        self._with_posix_paths()
1000
 
        self.assertRaises(PathNotChild,
1001
 
            urlutils.file_relpath, "file:///a/b", "file:///a/c")
1002
 
        self.assertRaises(PathNotChild,
1003
 
            urlutils.file_relpath, "file:///a/b/", "file:///a/c")
1004
 
        self.assertRaises(PathNotChild,
1005
 
            urlutils.file_relpath, "file:///a/b/", "file:///a/c/")
1006
 
 
1007
 
    def test_sibling_win32(self):
1008
 
        self._with_win32_paths()
1009
 
        self.assertRaises(PathNotChild,
1010
 
            urlutils.file_relpath, "file:///A:/b", "file:///A:/c")
1011
 
        self.assertRaises(PathNotChild,
1012
 
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c")
1013
 
        self.assertRaises(PathNotChild,
1014
 
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c/")
1015
 
 
1016
 
    def test_parent_posix(self):
1017
 
        self._with_posix_paths()
1018
 
        self.assertRaises(PathNotChild,
1019
 
            urlutils.file_relpath, "file:///a/b", "file:///a")
1020
 
        self.assertRaises(PathNotChild,
1021
 
            urlutils.file_relpath, "file:///a/b", "file:///a/")
1022
 
 
1023
 
    def test_parent_win32(self):
1024
 
        self._with_win32_paths()
1025
 
        self.assertRaises(PathNotChild,
1026
 
            urlutils.file_relpath, "file:///A:/b", "file:///A:/")
1027
 
        self.assertRaises(PathNotChild,
1028
 
            urlutils.file_relpath, "file:///A:/b/c", "file:///A:/b")
1029
 
 
1030
 
 
1031
 
class QuoteTests(TestCase):
1032
 
 
1033
 
    def test_quote(self):
1034
 
        self.assertEqual('abc%20def', urlutils.quote('abc def'))
1035
 
        self.assertEqual('abc%2Fdef', urlutils.quote('abc/def', safe=''))
1036
 
        self.assertEqual('abc/def', urlutils.quote('abc/def', safe='/'))
1037
 
 
1038
 
    def test_quote_tildes(self):
1039
 
        self.assertEqual('%7Efoo', urlutils.quote('~foo'))
1040
 
        self.assertEqual('~foo', urlutils.quote('~foo', safe='/~'))
1041
 
 
1042
 
    def test_unquote(self):
1043
 
        self.assertEqual('%', urlutils.unquote('%25'))
1044
 
        self.assertEqual('\xc3\xa5', urlutils.unquote('%C3%A5'))
1045
 
        self.assertEqual(u"\xe5", urlutils.unquote(u'\xe5'))
 
683
    def test_parse_url(self):
 
684
        self.assertEqual(urlutils.parse_url('http://example.com:80/one'),
 
685
            ('http', None, None, 'example.com', 80, '/one'))
 
686
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]/one'),
 
687
                ('http', None, None, '1:2:3::40', None, '/one'))
 
688
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]:80/one'),
 
689
                ('http', None, None, '1:2:3::40', 80, '/one'))