← 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: Martin
  • Date: 2010-05-16 12:21:31 UTC
  • mto: This revision was merged to the branch mainline in revision 5237.
  • Revision ID: gzlist@googlemail.com-20100516122131-6y6dh5grn27czjuh
https://launchpad.net/bugs/581298
Rename test method in bt.test__walkdirs_win32 that clashes with an attribute name

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2006-2012, 2015, 2016 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
 
    )
29
 
from bzrlib.tests import features, TestCaseInTempDir, TestCase, TestSkipped
 
23
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
 
24
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
30
25
 
31
26
 
32
27
class TestUrlToPath(TestCase):
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.assertEqual("/somedir/path", 
300
 
            join_segment_parameters_raw("/somedir/path"))
301
 
        self.assertEqual("/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.assertEqual("/somedir/path,bla,bar",
307
 
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
308
 
        self.assertEqual("/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.assertEqual("/somedir/path", 
317
 
            join_segment_parameters("/somedir/path", {}))
318
 
        self.assertEqual("/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.assertEqual("/somedir/path,key1=val1,key2=val2",
326
 
            join_segment_parameters("/somedir/path", {
327
 
                "key1": "val1", "key2": "val2"}))
328
 
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
329
 
            join_segment_parameters("/somedir/path,key1=val1", {
330
 
                "key2": "val2"}))
331
 
        self.assertEqual("/somedir/path,key1=val2",
332
 
            join_segment_parameters("/somedir/path,key1=val1", {
333
 
                "key1": "val2"}))
334
 
        self.assertEqual("/somedir,exist=some/path,key1=val1",
335
 
            join_segment_parameters("/somedir,exist=some/path",
336
 
                {"key1": "val1"}))
337
 
        self.assertEqual("/,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:
411
331
        self.assertFalse(isinstance(result, unicode))
412
332
 
413
333
    def test_win32_unc_path_to_url(self):
414
 
        self.requireFeature(features.win32_feature)
415
334
        to_url = urlutils._win32_local_path_to_url
416
335
        self.assertEqual('file://HOST/path',
417
336
            to_url(r'\\HOST\path'))
435
354
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
436
355
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
437
356
        self.assertEqual('/', from_url('file:///'))
438
 
        self.assertEqual('C:/path/to/foo',
439
 
            from_url('file:///C|/path/to/foo,branch=foo'))
440
357
 
441
 
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
442
 
        self.assertRaises(InvalidURL, from_url, 'file:///c')
443
358
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
444
359
        # Not a valid _win32 url, no drive letter
445
360
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
447
362
    def test_win32_unc_path_from_url(self):
448
363
        from_url = urlutils._win32_local_path_from_url
449
364
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
450
 
        self.assertEqual('//HOST/path',
451
 
            from_url('file://HOST/path,branch=foo'))
452
365
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
453
366
        # we want to use only 2 slashes
454
367
        # Firefox understand only 5 slashes in URL, but it's ugly
463
376
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
464
377
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
465
378
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
466
 
        # Root drives without slash treated as invalid, see bug #841322
467
 
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
468
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C:')
469
 
        # Invalid without drive separator or following forward slash
470
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C')
471
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C:ool')
472
379
 
473
380
    def test_split(self):
474
381
        # Test bzrlib.urlutils.split()
505
412
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
506
413
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
507
414
 
508
 
    def test_split_segment_parameters_raw(self):
509
 
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
510
 
        # Check relative references with absolute paths
511
 
        self.assertEqual(("/some/path", []),
512
 
            split_segment_parameters_raw("/some/path"))
513
 
        self.assertEqual(("/some/path", ["tip"]),
514
 
            split_segment_parameters_raw("/some/path,tip"))
515
 
        self.assertEqual(("/some,dir/path", ["tip"]),
516
 
            split_segment_parameters_raw("/some,dir/path,tip"))
517
 
        self.assertEqual(("/somedir/path", ["heads%2Ftip"]),
518
 
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
519
 
        self.assertEqual(("/somedir/path", ["heads%2Ftip", "bar"]),
520
 
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
521
 
        # Check relative references with relative paths
522
 
        self.assertEqual(("", ["key1=val1"]),
523
 
            split_segment_parameters_raw(",key1=val1"))
524
 
        self.assertEqual(("foo/", ["key1=val1"]),
525
 
            split_segment_parameters_raw("foo/,key1=val1"))
526
 
        self.assertEqual(("foo", ["key1=val1"]),
527
 
            split_segment_parameters_raw("foo,key1=val1"))
528
 
        self.assertEqual(("foo/base,la=bla/other/elements", []),
529
 
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
530
 
        self.assertEqual(("foo/base,la=bla/other/elements", ["a=b"]),
531
 
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
532
 
        # TODO: Check full URLs as well as relative references
533
 
 
534
 
    def test_split_segment_parameters(self):
535
 
        split_segment_parameters = urlutils.split_segment_parameters
536
 
        # Check relative references with absolute paths
537
 
        self.assertEqual(("/some/path", {}),
538
 
            split_segment_parameters("/some/path"))
539
 
        self.assertEqual(("/some/path", {"branch": "tip"}),
540
 
            split_segment_parameters("/some/path,branch=tip"))
541
 
        self.assertEqual(("/some,dir/path", {"branch": "tip"}),
542
 
            split_segment_parameters("/some,dir/path,branch=tip"))
543
 
        self.assertEqual(("/somedir/path", {"ref": "heads%2Ftip"}),
544
 
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
545
 
        self.assertEqual(("/somedir/path",
546
 
            {"ref": "heads%2Ftip", "key1": "val1"}),
547
 
            split_segment_parameters(
548
 
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
549
 
        self.assertEqual(("/somedir/path", {"ref": "heads%2F=tip"}),
550
 
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
551
 
        # Check relative references with relative paths
552
 
        self.assertEqual(("", {"key1": "val1"}),
553
 
            split_segment_parameters(",key1=val1"))
554
 
        self.assertEqual(("foo/", {"key1": "val1"}),
555
 
            split_segment_parameters("foo/,key1=val1"))
556
 
        self.assertEqual(("foo/base,key1=val1/other/elements", {}),
557
 
            split_segment_parameters("foo/base,key1=val1/other/elements"))
558
 
        self.assertEqual(("foo/base,key1=val1/other/elements",
559
 
            {"key2": "val2"}), split_segment_parameters(
560
 
                "foo/base,key1=val1/other/elements,key2=val2"))
561
 
        # TODO: Check full URLs as well as relative references
562
 
 
563
415
    def test_win32_strip_local_trailing_slash(self):
564
416
        strip = urlutils._win32_strip_local_trailing_slash
565
417
        self.assertEqual('file://', strip('file://'))
726
578
 
727
579
 
728
580
class TestCwdToURL(TestCaseInTempDir):
729
 
    """Test that local_path_to_url works based on the cwd"""
 
581
    """Test that local_path_to_url works base on the cwd"""
730
582
 
731
583
    def test_dot(self):
732
584
        # This test will fail if getcwd is not ascii
828
680
 
829
681
class TestParseURL(TestCase):
830
682
 
831
 
    def test_parse_simple(self):
832
 
        parsed = urlutils.parse_url('http://example.com:80/one')
833
 
        self.assertEqual(('http', None, None, 'example.com', 80, '/one'),
834
 
            parsed)
835
 
 
836
 
    def test_ipv6(self):
837
 
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
838
 
        self.assertEqual(('http', None, None, '1:2:3::40', None, '/one'),
839
 
            parsed)
840
 
 
841
 
    def test_ipv6_port(self):
842
 
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
843
 
        self.assertEqual(('http', None, None, '1:2:3::40', 80, '/one'),
844
 
            parsed)
845
 
 
846
 
 
847
 
class TestURL(TestCase):
848
 
 
849
 
    def test_parse_simple(self):
850
 
        parsed = urlutils.URL.from_string('http://example.com:80/one')
851
 
        self.assertEqual('http', parsed.scheme)
852
 
        self.assertIs(None, parsed.user)
853
 
        self.assertIs(None, parsed.password)
854
 
        self.assertEqual('example.com', parsed.host)
855
 
        self.assertEqual(80, parsed.port)
856
 
        self.assertEqual('/one', parsed.path)
857
 
 
858
 
    def test_ipv6(self):
859
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
860
 
        self.assertEqual('http', parsed.scheme)
861
 
        self.assertIs(None, parsed.port)
862
 
        self.assertIs(None, parsed.user)
863
 
        self.assertIs(None, parsed.password)
864
 
        self.assertEqual('1:2:3::40', parsed.host)
865
 
        self.assertEqual('/one', parsed.path)
866
 
 
867
 
    def test_ipv6_port(self):
868
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
869
 
        self.assertEqual('http', parsed.scheme)
870
 
        self.assertEqual('1:2:3::40', parsed.host)
871
 
        self.assertIs(None, parsed.user)
872
 
        self.assertIs(None, parsed.password)
873
 
        self.assertEqual(80, parsed.port)
874
 
        self.assertEqual('/one', parsed.path)
875
 
 
876
 
    def test_quoted(self):
877
 
        parsed = urlutils.URL.from_string(
878
 
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
879
 
        self.assertEqual(parsed.quoted_host, 'ex%41mple.com')
880
 
        self.assertEqual(parsed.host, 'exAmple.com')
881
 
        self.assertEqual(parsed.port, 2222)
882
 
        self.assertEqual(parsed.quoted_user, 'ro%62ey')
883
 
        self.assertEqual(parsed.user, 'robey')
884
 
        self.assertEqual(parsed.quoted_password, 'h%40t')
885
 
        self.assertEqual(parsed.password, 'h@t')
886
 
        self.assertEqual(parsed.path, '/path')
887
 
 
888
 
    def test_eq(self):
889
 
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
890
 
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
891
 
        self.assertEqual(parsed1, parsed2)
892
 
        self.assertEqual(parsed1, parsed1)
893
 
        parsed2.path = '/two'
894
 
        self.assertNotEqual(parsed1, parsed2)
895
 
 
896
 
    def test_repr(self):
897
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
898
 
        self.assertEqual(
899
 
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
900
 
            repr(parsed))
901
 
 
902
 
    def test_str(self):
903
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
904
 
        self.assertEqual('http://[1:2:3::40]:80/one', str(parsed))
905
 
 
906
 
    def test__combine_paths(self):
907
 
        combine = urlutils.URL._combine_paths
908
 
        self.assertEqual('/home/sarah/project/foo',
909
 
                         combine('/home/sarah', 'project/foo'))
910
 
        self.assertEqual('/etc',
911
 
                         combine('/home/sarah', '../../etc'))
912
 
        self.assertEqual('/etc',
913
 
                         combine('/home/sarah', '../../../etc'))
914
 
        self.assertEqual('/etc',
915
 
                         combine('/home/sarah', '/etc'))
916
 
 
917
 
    def test_clone(self):
918
 
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
919
 
        url1 = url.clone("two")
920
 
        self.assertEqual("/one/two", url1.path)
921
 
        url2 = url.clone("/two")
922
 
        self.assertEqual("/two", url2.path)
923
 
        url3 = url.clone()
924
 
        self.assertIsNot(url, url3)
925
 
        self.assertEqual(url, url3)
926
 
 
927
 
 
928
 
class TestFileRelpath(TestCase):
929
 
 
930
 
    # GZ 2011-11-18: A way to override all path handling functions to one
931
 
    #                platform or another for testing would be nice.
932
 
 
933
 
    def _with_posix_paths(self):
934
 
        self.overrideAttr(urlutils, "local_path_from_url",
935
 
            urlutils._posix_local_path_from_url)
936
 
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH", len("file:///"))
937
 
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
938
 
        self.overrideAttr(osutils, "abspath", osutils._posix_abspath)
939
 
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
940
 
        self.overrideAttr(osutils, "pathjoin", osutils.posixpath.join)
941
 
        self.overrideAttr(osutils, "split", osutils.posixpath.split)
942
 
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 1)
943
 
 
944
 
    def _with_win32_paths(self):
945
 
        self.overrideAttr(urlutils, "local_path_from_url",
946
 
            urlutils._win32_local_path_from_url)
947
 
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH",
948
 
            urlutils.WIN32_MIN_ABS_FILEURL_LENGTH)
949
 
        self.overrideAttr(osutils, "abspath", osutils._win32_abspath)
950
 
        self.overrideAttr(osutils, "normpath", osutils._win32_normpath)
951
 
        self.overrideAttr(osutils, "pathjoin", osutils._win32_pathjoin)
952
 
        self.overrideAttr(osutils, "split", osutils.ntpath.split)
953
 
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 3)
954
 
 
955
 
    def test_same_url_posix(self):
956
 
        self._with_posix_paths()
957
 
        self.assertEqual("",
958
 
            urlutils.file_relpath("file:///a", "file:///a"))
959
 
        self.assertEqual("",
960
 
            urlutils.file_relpath("file:///a", "file:///a/"))
961
 
        self.assertEqual("",
962
 
            urlutils.file_relpath("file:///a/", "file:///a"))
963
 
 
964
 
    def test_same_url_win32(self):
965
 
        self._with_win32_paths()
966
 
        self.assertEqual("",
967
 
            urlutils.file_relpath("file:///A:/", "file:///A:/"))
968
 
        self.assertEqual("",
969
 
            urlutils.file_relpath("file:///A|/", "file:///A:/"))
970
 
        self.assertEqual("",
971
 
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
972
 
        self.assertEqual("",
973
 
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
974
 
        self.assertEqual("",
975
 
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
976
 
 
977
 
    def test_child_posix(self):
978
 
        self._with_posix_paths()
979
 
        self.assertEqual("b",
980
 
            urlutils.file_relpath("file:///a", "file:///a/b"))
981
 
        self.assertEqual("b",
982
 
            urlutils.file_relpath("file:///a/", "file:///a/b"))
983
 
        self.assertEqual("b/c",
984
 
            urlutils.file_relpath("file:///a", "file:///a/b/c"))
985
 
 
986
 
    def test_child_win32(self):
987
 
        self._with_win32_paths()
988
 
        self.assertEqual("b",
989
 
            urlutils.file_relpath("file:///A:/", "file:///A:/b"))
990
 
        self.assertEqual("b",
991
 
            urlutils.file_relpath("file:///A|/", "file:///A:/b"))
992
 
        self.assertEqual("c",
993
 
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
994
 
        self.assertEqual("c",
995
 
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
996
 
        self.assertEqual("c/d",
997
 
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
998
 
 
999
 
    def test_sibling_posix(self):
1000
 
        self._with_posix_paths()
1001
 
        self.assertRaises(PathNotChild,
1002
 
            urlutils.file_relpath, "file:///a/b", "file:///a/c")
1003
 
        self.assertRaises(PathNotChild,
1004
 
            urlutils.file_relpath, "file:///a/b/", "file:///a/c")
1005
 
        self.assertRaises(PathNotChild,
1006
 
            urlutils.file_relpath, "file:///a/b/", "file:///a/c/")
1007
 
 
1008
 
    def test_sibling_win32(self):
1009
 
        self._with_win32_paths()
1010
 
        self.assertRaises(PathNotChild,
1011
 
            urlutils.file_relpath, "file:///A:/b", "file:///A:/c")
1012
 
        self.assertRaises(PathNotChild,
1013
 
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c")
1014
 
        self.assertRaises(PathNotChild,
1015
 
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c/")
1016
 
 
1017
 
    def test_parent_posix(self):
1018
 
        self._with_posix_paths()
1019
 
        self.assertRaises(PathNotChild,
1020
 
            urlutils.file_relpath, "file:///a/b", "file:///a")
1021
 
        self.assertRaises(PathNotChild,
1022
 
            urlutils.file_relpath, "file:///a/b", "file:///a/")
1023
 
 
1024
 
    def test_parent_win32(self):
1025
 
        self._with_win32_paths()
1026
 
        self.assertRaises(PathNotChild,
1027
 
            urlutils.file_relpath, "file:///A:/b", "file:///A:/")
1028
 
        self.assertRaises(PathNotChild,
1029
 
            urlutils.file_relpath, "file:///A:/b/c", "file:///A:/b")
1030
 
 
1031
 
 
1032
 
class QuoteTests(TestCase):
1033
 
 
1034
 
    def test_quote(self):
1035
 
        self.assertEqual('abc%20def', urlutils.quote('abc def'))
1036
 
        self.assertEqual('abc%2Fdef', urlutils.quote('abc/def', safe=''))
1037
 
        self.assertEqual('abc/def', urlutils.quote('abc/def', safe='/'))
1038
 
 
1039
 
    def test_quote_tildes(self):
1040
 
        self.assertEqual('%7Efoo', urlutils.quote('~foo'))
1041
 
        self.assertEqual('~foo', urlutils.quote('~foo', safe='/~'))
1042
 
 
1043
 
    def test_unquote(self):
1044
 
        self.assertEqual('%', urlutils.unquote('%25'))
1045
 
        self.assertEqual('\xc3\xa5', urlutils.unquote('%C3%A5'))
1046
 
        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'))