← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

(gz) Remove bzrlib/util/elementtree/ package (Martin Packman)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
20
20
import sys
21
21
 
22
22
from bzrlib import osutils, urlutils, win32utils
23
 
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
 
23
from bzrlib.errors import (
 
24
    InvalidURL,
 
25
    InvalidURLJoin,
 
26
    InvalidRebaseURLs,
 
27
    PathNotChild,
 
28
    )
24
29
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
25
30
 
26
31
 
336
341
 
337
342
    def test_function_type(self):
338
343
        if sys.platform == 'win32':
339
 
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
340
 
            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)
341
348
        else:
342
 
            self.assertEqual(urlutils._posix_local_path_to_url, urlutils.local_path_to_url)
343
 
            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)
344
353
 
345
354
    def test_posix_local_path_to_url(self):
346
355
        to_url = urlutils._posix_local_path_to_url
347
356
        self.assertEqual('file:///path/to/foo',
348
357
            to_url('/path/to/foo'))
349
358
 
 
359
        self.assertEqual('file:///path/to/foo%2Cbar',
 
360
            to_url('/path/to/foo,bar'))
 
361
 
350
362
        try:
351
363
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
352
364
        except UnicodeError:
359
371
        from_url = urlutils._posix_local_path_from_url
360
372
        self.assertEqual('/path/to/foo',
361
373
            from_url('file:///path/to/foo'))
 
374
        self.assertEqual('/path/to/foo',
 
375
            from_url('file:///path/to/foo,branch=foo'))
362
376
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
363
377
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
364
378
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
386
400
 
387
401
        self.assertEqual('file:///', to_url('/'))
388
402
 
 
403
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
 
404
            to_url('C:/path/to/foo,bar'))
389
405
        try:
390
406
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
391
407
        except UnicodeError:
418
434
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
419
435
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
420
436
        self.assertEqual('/', from_url('file:///'))
 
437
        self.assertEqual('C:/path/to/foo',
 
438
            from_url('file:///C|/path/to/foo,branch=foo'))
421
439
 
422
440
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
423
441
        self.assertRaises(InvalidURL, from_url, 'file:///c')
428
446
    def test_win32_unc_path_from_url(self):
429
447
        from_url = urlutils._win32_local_path_from_url
430
448
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
 
449
        self.assertEqual('//HOST/path',
 
450
            from_url('file://HOST/path,branch=foo'))
431
451
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
432
452
        # we want to use only 2 slashes
433
453
        # Firefox understand only 5 slashes in URL, but it's ugly
442
462
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
443
463
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
444
464
        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')
445
471
 
446
472
    def test_split(self):
447
473
        # Test bzrlib.urlutils.split()
480
506
 
481
507
    def test_split_segment_parameters_raw(self):
482
508
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
 
509
        # Check relative references with absolute paths
483
510
        self.assertEquals(("/some/path", []),
484
511
            split_segment_parameters_raw("/some/path"))
485
512
        self.assertEquals(("/some/path", ["tip"]),
490
517
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
491
518
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
492
519
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
493
 
        self.assertEquals(("/", ["key1=val1"]),
 
520
        # Check relative references with relative paths
 
521
        self.assertEquals(("", ["key1=val1"]),
494
522
            split_segment_parameters_raw(",key1=val1"))
495
523
        self.assertEquals(("foo/", ["key1=val1"]),
496
524
            split_segment_parameters_raw("foo/,key1=val1"))
 
525
        self.assertEquals(("foo", ["key1=val1"]),
 
526
            split_segment_parameters_raw("foo,key1=val1"))
497
527
        self.assertEquals(("foo/base,la=bla/other/elements", []),
498
528
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
499
529
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
500
530
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
 
531
        # TODO: Check full URLs as well as relative references
501
532
 
502
533
    def test_split_segment_parameters(self):
503
534
        split_segment_parameters = urlutils.split_segment_parameters
 
535
        # Check relative references with absolute paths
504
536
        self.assertEquals(("/some/path", {}),
505
537
            split_segment_parameters("/some/path"))
506
538
        self.assertEquals(("/some/path", {"branch": "tip"}),
515
547
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
516
548
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
517
549
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
518
 
        self.assertEquals(("/", {"key1": "val1"}),
 
550
        # Check relative references with relative paths
 
551
        self.assertEquals(("", {"key1": "val1"}),
519
552
            split_segment_parameters(",key1=val1"))
520
553
        self.assertEquals(("foo/", {"key1": "val1"}),
521
554
            split_segment_parameters("foo/,key1=val1"))
524
557
        self.assertEquals(("foo/base,key1=val1/other/elements",
525
558
            {"key2": "val2"}), split_segment_parameters(
526
559
                "foo/base,key1=val1/other/elements,key2=val2"))
 
560
        # TODO: Check full URLs as well as relative references
527
561
 
528
562
    def test_win32_strip_local_trailing_slash(self):
529
563
        strip = urlutils._win32_strip_local_trailing_slash
793
827
 
794
828
class TestParseURL(TestCase):
795
829
 
796
 
    def test_parse_url(self):
797
 
        self.assertEqual(urlutils.parse_url('http://example.com:80/one'),
798
 
            ('http', None, None, 'example.com', 80, '/one'))
799
 
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]/one'),
800
 
                ('http', None, None, '1:2:3::40', None, '/one'))
801
 
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]:80/one'),
802
 
                ('http', None, None, '1:2:3::40', 80, '/one'))
 
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'))