/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_urlutils.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-10 21:59:15 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170610215915-zcpu0in3r1irx3ml
Move serializer to bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_urlutils.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2015, 2016 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
19
19
import os
20
20
import sys
21
21
 
22
 
from bzrlib import osutils, urlutils, win32utils
23
 
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
24
 
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
 
22
from .. import osutils, urlutils, win32utils
 
23
from ..errors import (
 
24
    InvalidURL,
 
25
    InvalidURLJoin,
 
26
    InvalidRebaseURLs,
 
27
    PathNotChild,
 
28
    )
 
29
from . import features, TestCaseInTempDir, TestCase, TestSkipped
25
30
 
26
31
 
27
32
class TestUrlToPath(TestCase):
28
33
 
29
34
    def test_basename(self):
30
 
        # bzrlib.urlutils.basename
31
 
        # Test bzrlib.urlutils.split()
 
35
        # breezy.urlutils.basename
 
36
        # Test breezy.urlutils.split()
32
37
        basename = urlutils.basename
33
38
        if sys.platform == 'win32':
34
39
            self.assertRaises(InvalidURL, basename, 'file:///path/to/foo')
156
161
        # Weird stuff
157
162
        # Can't have slashes or colons in the scheme
158
163
        test_one('/path/to/://foo', None)
159
 
        test_one('path:path://foo', None)
 
164
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
160
165
        # Must have more than one character for scheme
161
166
        test_one('C://foo', None)
162
167
        test_one('ab://foo', ('ab', 'foo'))
163
168
 
164
169
    def test_dirname(self):
165
 
        # Test bzrlib.urlutils.dirname()
 
170
        # Test breezy.urlutils.dirname()
166
171
        dirname = urlutils.dirname
167
172
        if sys.platform == 'win32':
168
173
            self.assertRaises(InvalidURL, dirname, 'file:///path/to/foo')
195
200
            dirname('path/to/foo/', exclude_trailing_slash=False))
196
201
        self.assertEqual('path/..', dirname('path/../foo'))
197
202
        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'))
198
217
 
199
218
    def test_join(self):
200
219
        def test(expected, *args):
210
229
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
211
230
        test('http://foo/baz', 'http://foo', 'bar/../baz')
212
231
        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')
213
234
 
214
235
        # Absolute paths
215
236
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
219
240
        test('http://bar/', 'http://foo', 'http://bar/')
220
241
        test('http://bar/a', 'http://foo', 'http://bar/a')
221
242
        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')
222
246
 
223
247
        # From a base path
224
248
        test('file:///foo', 'file:///', 'foo')
270
294
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
271
295
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
272
296
 
 
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
 
273
342
    def test_function_type(self):
274
343
        if sys.platform == 'win32':
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)
 
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)
277
348
        else:
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)
 
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)
280
353
 
281
354
    def test_posix_local_path_to_url(self):
282
355
        to_url = urlutils._posix_local_path_to_url
283
356
        self.assertEqual('file:///path/to/foo',
284
357
            to_url('/path/to/foo'))
285
358
 
 
359
        self.assertEqual('file:///path/to/foo%2Cbar',
 
360
            to_url('/path/to/foo,bar'))
 
361
 
286
362
        try:
287
363
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
288
364
        except UnicodeError:
295
371
        from_url = urlutils._posix_local_path_from_url
296
372
        self.assertEqual('/path/to/foo',
297
373
            from_url('file:///path/to/foo'))
 
374
        self.assertEqual('/path/to/foo',
 
375
            from_url('file:///path/to/foo,branch=foo'))
298
376
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
299
377
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
300
378
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
322
400
 
323
401
        self.assertEqual('file:///', to_url('/'))
324
402
 
 
403
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
 
404
            to_url('C:/path/to/foo,bar'))
325
405
        try:
326
406
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
327
407
        except UnicodeError:
331
411
        self.assertFalse(isinstance(result, unicode))
332
412
 
333
413
    def test_win32_unc_path_to_url(self):
 
414
        self.requireFeature(features.win32_feature)
334
415
        to_url = urlutils._win32_local_path_to_url
335
416
        self.assertEqual('file://HOST/path',
336
417
            to_url(r'\\HOST\path'))
354
435
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
355
436
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
356
437
        self.assertEqual('/', from_url('file:///'))
 
438
        self.assertEqual('C:/path/to/foo',
 
439
            from_url('file:///C|/path/to/foo,branch=foo'))
357
440
 
 
441
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
 
442
        self.assertRaises(InvalidURL, from_url, 'file:///c')
358
443
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
359
444
        # Not a valid _win32 url, no drive letter
360
445
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
362
447
    def test_win32_unc_path_from_url(self):
363
448
        from_url = urlutils._win32_local_path_from_url
364
449
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
 
450
        self.assertEqual('//HOST/path',
 
451
            from_url('file://HOST/path,branch=foo'))
365
452
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
366
453
        # we want to use only 2 slashes
367
454
        # Firefox understand only 5 slashes in URL, but it's ugly
376
463
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
377
464
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
378
465
        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')
379
472
 
380
473
    def test_split(self):
381
 
        # Test bzrlib.urlutils.split()
 
474
        # Test breezy.urlutils.split()
382
475
        split = urlutils.split
383
476
        if sys.platform == 'win32':
384
477
            self.assertRaises(InvalidURL, split, 'file:///path/to/foo')
412
505
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
413
506
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
414
507
 
 
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
 
415
563
    def test_win32_strip_local_trailing_slash(self):
416
564
        strip = urlutils._win32_strip_local_trailing_slash
417
565
        self.assertEqual('file://', strip('file://'))
578
726
 
579
727
 
580
728
class TestCwdToURL(TestCaseInTempDir):
581
 
    """Test that local_path_to_url works base on the cwd"""
 
729
    """Test that local_path_to_url works based on the cwd"""
582
730
 
583
731
    def test_dot(self):
584
732
        # This test will fail if getcwd is not ascii
589
737
        self.assertEndsWith(url, '/mytest')
590
738
 
591
739
    def test_non_ascii(self):
592
 
        if win32utils.winver == 'Windows 98':
593
 
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
594
 
 
595
740
        try:
596
741
            os.mkdir(u'dod\xe9')
597
742
        except UnicodeError:
680
825
 
681
826
class TestParseURL(TestCase):
682
827
 
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'))
 
828
    def test_parse_simple(self):
 
829
        parsed = urlutils.parse_url('http://example.com:80/one')
 
830
        self.assertEqual(('http', None, None, 'example.com', 80, '/one'),
 
831
            parsed)
 
832
 
 
833
    def test_ipv6(self):
 
834
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
 
835
        self.assertEqual(('http', None, None, '1:2:3::40', None, '/one'),
 
836
            parsed)
 
837
 
 
838
    def test_ipv6_port(self):
 
839
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
 
840
        self.assertEqual(('http', None, None, '1:2:3::40', 80, '/one'),
 
841
            parsed)
 
842
 
 
843
 
 
844
class TestURL(TestCase):
 
845
 
 
846
    def test_parse_simple(self):
 
847
        parsed = urlutils.URL.from_string('http://example.com:80/one')
 
848
        self.assertEqual('http', parsed.scheme)
 
849
        self.assertIs(None, parsed.user)
 
850
        self.assertIs(None, parsed.password)
 
851
        self.assertEqual('example.com', parsed.host)
 
852
        self.assertEqual(80, parsed.port)
 
853
        self.assertEqual('/one', parsed.path)
 
854
 
 
855
    def test_ipv6(self):
 
856
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
 
857
        self.assertEqual('http', parsed.scheme)
 
858
        self.assertIs(None, parsed.port)
 
859
        self.assertIs(None, parsed.user)
 
860
        self.assertIs(None, parsed.password)
 
861
        self.assertEqual('1:2:3::40', parsed.host)
 
862
        self.assertEqual('/one', parsed.path)
 
863
 
 
864
    def test_ipv6_port(self):
 
865
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
866
        self.assertEqual('http', parsed.scheme)
 
867
        self.assertEqual('1:2:3::40', parsed.host)
 
868
        self.assertIs(None, parsed.user)
 
869
        self.assertIs(None, parsed.password)
 
870
        self.assertEqual(80, parsed.port)
 
871
        self.assertEqual('/one', parsed.path)
 
872
 
 
873
    def test_quoted(self):
 
874
        parsed = urlutils.URL.from_string(
 
875
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
 
876
        self.assertEqual(parsed.quoted_host, 'ex%41mple.com')
 
877
        self.assertEqual(parsed.host, 'exAmple.com')
 
878
        self.assertEqual(parsed.port, 2222)
 
879
        self.assertEqual(parsed.quoted_user, 'ro%62ey')
 
880
        self.assertEqual(parsed.user, 'robey')
 
881
        self.assertEqual(parsed.quoted_password, 'h%40t')
 
882
        self.assertEqual(parsed.password, 'h@t')
 
883
        self.assertEqual(parsed.path, '/path')
 
884
 
 
885
    def test_eq(self):
 
886
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
887
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
888
        self.assertEqual(parsed1, parsed2)
 
889
        self.assertEqual(parsed1, parsed1)
 
890
        parsed2.path = '/two'
 
891
        self.assertNotEqual(parsed1, parsed2)
 
892
 
 
893
    def test_repr(self):
 
894
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
895
        self.assertEqual(
 
896
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
 
897
            repr(parsed))
 
898
 
 
899
    def test_str(self):
 
900
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
901
        self.assertEqual('http://[1:2:3::40]:80/one', str(parsed))
 
902
 
 
903
    def test__combine_paths(self):
 
904
        combine = urlutils.URL._combine_paths
 
905
        self.assertEqual('/home/sarah/project/foo',
 
906
                         combine('/home/sarah', 'project/foo'))
 
907
        self.assertEqual('/etc',
 
908
                         combine('/home/sarah', '../../etc'))
 
909
        self.assertEqual('/etc',
 
910
                         combine('/home/sarah', '../../../etc'))
 
911
        self.assertEqual('/etc',
 
912
                         combine('/home/sarah', '/etc'))
 
913
 
 
914
    def test_clone(self):
 
915
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
916
        url1 = url.clone("two")
 
917
        self.assertEqual("/one/two", url1.path)
 
918
        url2 = url.clone("/two")
 
919
        self.assertEqual("/two", url2.path)
 
920
        url3 = url.clone()
 
921
        self.assertIsNot(url, url3)
 
922
        self.assertEqual(url, url3)
 
923
 
 
924
 
 
925
class TestFileRelpath(TestCase):
 
926
 
 
927
    # GZ 2011-11-18: A way to override all path handling functions to one
 
928
    #                platform or another for testing would be nice.
 
929
 
 
930
    def _with_posix_paths(self):
 
931
        self.overrideAttr(urlutils, "local_path_from_url",
 
932
            urlutils._posix_local_path_from_url)
 
933
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH", len("file:///"))
 
934
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
 
935
        self.overrideAttr(osutils, "abspath", osutils._posix_abspath)
 
936
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
 
937
        self.overrideAttr(osutils, "pathjoin", osutils.posixpath.join)
 
938
        self.overrideAttr(osutils, "split", osutils.posixpath.split)
 
939
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 1)
 
940
 
 
941
    def _with_win32_paths(self):
 
942
        self.overrideAttr(urlutils, "local_path_from_url",
 
943
            urlutils._win32_local_path_from_url)
 
944
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH",
 
945
            urlutils.WIN32_MIN_ABS_FILEURL_LENGTH)
 
946
        self.overrideAttr(osutils, "abspath", osutils._win32_abspath)
 
947
        self.overrideAttr(osutils, "normpath", osutils._win32_normpath)
 
948
        self.overrideAttr(osutils, "pathjoin", osutils._win32_pathjoin)
 
949
        self.overrideAttr(osutils, "split", osutils.ntpath.split)
 
950
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 3)
 
951
 
 
952
    def test_same_url_posix(self):
 
953
        self._with_posix_paths()
 
954
        self.assertEqual("",
 
955
            urlutils.file_relpath("file:///a", "file:///a"))
 
956
        self.assertEqual("",
 
957
            urlutils.file_relpath("file:///a", "file:///a/"))
 
958
        self.assertEqual("",
 
959
            urlutils.file_relpath("file:///a/", "file:///a"))
 
960
 
 
961
    def test_same_url_win32(self):
 
962
        self._with_win32_paths()
 
963
        self.assertEqual("",
 
964
            urlutils.file_relpath("file:///A:/", "file:///A:/"))
 
965
        self.assertEqual("",
 
966
            urlutils.file_relpath("file:///A|/", "file:///A:/"))
 
967
        self.assertEqual("",
 
968
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
 
969
        self.assertEqual("",
 
970
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
 
971
        self.assertEqual("",
 
972
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
 
973
 
 
974
    def test_child_posix(self):
 
975
        self._with_posix_paths()
 
976
        self.assertEqual("b",
 
977
            urlutils.file_relpath("file:///a", "file:///a/b"))
 
978
        self.assertEqual("b",
 
979
            urlutils.file_relpath("file:///a/", "file:///a/b"))
 
980
        self.assertEqual("b/c",
 
981
            urlutils.file_relpath("file:///a", "file:///a/b/c"))
 
982
 
 
983
    def test_child_win32(self):
 
984
        self._with_win32_paths()
 
985
        self.assertEqual("b",
 
986
            urlutils.file_relpath("file:///A:/", "file:///A:/b"))
 
987
        self.assertEqual("b",
 
988
            urlutils.file_relpath("file:///A|/", "file:///A:/b"))
 
989
        self.assertEqual("c",
 
990
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
 
991
        self.assertEqual("c",
 
992
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
 
993
        self.assertEqual("c/d",
 
994
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
 
995
 
 
996
    def test_sibling_posix(self):
 
997
        self._with_posix_paths()
 
998
        self.assertRaises(PathNotChild,
 
999
            urlutils.file_relpath, "file:///a/b", "file:///a/c")
 
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
 
 
1005
    def test_sibling_win32(self):
 
1006
        self._with_win32_paths()
 
1007
        self.assertRaises(PathNotChild,
 
1008
            urlutils.file_relpath, "file:///A:/b", "file:///A:/c")
 
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
 
 
1014
    def test_parent_posix(self):
 
1015
        self._with_posix_paths()
 
1016
        self.assertRaises(PathNotChild,
 
1017
            urlutils.file_relpath, "file:///a/b", "file:///a")
 
1018
        self.assertRaises(PathNotChild,
 
1019
            urlutils.file_relpath, "file:///a/b", "file:///a/")
 
1020
 
 
1021
    def test_parent_win32(self):
 
1022
        self._with_win32_paths()
 
1023
        self.assertRaises(PathNotChild,
 
1024
            urlutils.file_relpath, "file:///A:/b", "file:///A:/")
 
1025
        self.assertRaises(PathNotChild,
 
1026
            urlutils.file_relpath, "file:///A:/b/c", "file:///A:/b")
 
1027
 
 
1028
 
 
1029
class QuoteTests(TestCase):
 
1030
 
 
1031
    def test_quote(self):
 
1032
        self.assertEqual('abc%20def', urlutils.quote('abc def'))
 
1033
        self.assertEqual('abc%2Fdef', urlutils.quote('abc/def', safe=''))
 
1034
        self.assertEqual('abc/def', urlutils.quote('abc/def', safe='/'))
 
1035
 
 
1036
    def test_quote_tildes(self):
 
1037
        self.assertEqual('%7Efoo', urlutils.quote('~foo'))
 
1038
        self.assertEqual('~foo', urlutils.quote('~foo', safe='/~'))
 
1039
 
 
1040
    def test_unquote(self):
 
1041
        self.assertEqual('%', urlutils.unquote('%25'))
 
1042
        self.assertEqual('\xc3\xa5', urlutils.unquote('%C3%A5'))
 
1043
        self.assertEqual(u"\xe5", urlutils.unquote(u'\xe5'))