← 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: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/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
20
20
import sys
21
21
 
22
22
from bzrlib import osutils, urlutils, win32utils
23
 
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
24
 
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
 
23
from bzrlib.errors import (
 
24
    InvalidURL,
 
25
    InvalidURLJoin,
 
26
    InvalidRebaseURLs,
 
27
    PathNotChild,
 
28
    )
 
29
from bzrlib.tests import features, TestCaseInTempDir, TestCase, TestSkipped
25
30
 
26
31
 
27
32
class TestUrlToPath(TestCase):
291
296
 
292
297
    def test_join_segment_parameters_raw(self):
293
298
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
294
 
        self.assertEquals("/somedir/path", 
 
299
        self.assertEqual("/somedir/path", 
295
300
            join_segment_parameters_raw("/somedir/path"))
296
 
        self.assertEquals("/somedir/path,rawdata", 
 
301
        self.assertEqual("/somedir/path,rawdata", 
297
302
            join_segment_parameters_raw("/somedir/path", "rawdata"))
298
303
        self.assertRaises(InvalidURLJoin,
299
304
            join_segment_parameters_raw, "/somedir/path",
300
305
                "rawdata1,rawdata2,rawdata3")
301
 
        self.assertEquals("/somedir/path,bla,bar",
 
306
        self.assertEqual("/somedir/path,bla,bar",
302
307
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
303
 
        self.assertEquals("/somedir,exist=some/path,bla,bar",
 
308
        self.assertEqual("/somedir,exist=some/path,bla,bar",
304
309
            join_segment_parameters_raw("/somedir,exist=some/path",
305
310
                "bla", "bar"))
306
311
        self.assertRaises(TypeError, join_segment_parameters_raw, 
308
313
 
309
314
    def test_join_segment_parameters(self):
310
315
        join_segment_parameters = urlutils.join_segment_parameters
311
 
        self.assertEquals("/somedir/path", 
 
316
        self.assertEqual("/somedir/path", 
312
317
            join_segment_parameters("/somedir/path", {}))
313
 
        self.assertEquals("/somedir/path,key1=val1", 
 
318
        self.assertEqual("/somedir/path,key1=val1", 
314
319
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
315
320
        self.assertRaises(InvalidURLJoin,
316
321
            join_segment_parameters, "/somedir/path",
317
322
            {"branch": "brr,brr,brr"})
318
323
        self.assertRaises(InvalidURLJoin,
319
324
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
320
 
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
325
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
321
326
            join_segment_parameters("/somedir/path", {
322
327
                "key1": "val1", "key2": "val2"}))
323
 
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
328
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
324
329
            join_segment_parameters("/somedir/path,key1=val1", {
325
330
                "key2": "val2"}))
326
 
        self.assertEquals("/somedir/path,key1=val2",
 
331
        self.assertEqual("/somedir/path,key1=val2",
327
332
            join_segment_parameters("/somedir/path,key1=val1", {
328
333
                "key1": "val2"}))
329
 
        self.assertEquals("/somedir,exist=some/path,key1=val1",
 
334
        self.assertEqual("/somedir,exist=some/path,key1=val1",
330
335
            join_segment_parameters("/somedir,exist=some/path",
331
336
                {"key1": "val1"}))
332
 
        self.assertEquals("/,key1=val1,key2=val2",
 
337
        self.assertEqual("/,key1=val1,key2=val2",
333
338
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
334
339
        self.assertRaises(TypeError,
335
340
            join_segment_parameters, "/,key1=val1", {"foo": 42})
406
411
        self.assertFalse(isinstance(result, unicode))
407
412
 
408
413
    def test_win32_unc_path_to_url(self):
 
414
        self.requireFeature(features.win32_feature)
409
415
        to_url = urlutils._win32_local_path_to_url
410
416
        self.assertEqual('file://HOST/path',
411
417
            to_url(r'\\HOST\path'))
501
507
 
502
508
    def test_split_segment_parameters_raw(self):
503
509
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
504
 
        self.assertEquals(("/some/path", []),
 
510
        # Check relative references with absolute paths
 
511
        self.assertEqual(("/some/path", []),
505
512
            split_segment_parameters_raw("/some/path"))
506
 
        self.assertEquals(("/some/path", ["tip"]),
 
513
        self.assertEqual(("/some/path", ["tip"]),
507
514
            split_segment_parameters_raw("/some/path,tip"))
508
 
        self.assertEquals(("/some,dir/path", ["tip"]),
 
515
        self.assertEqual(("/some,dir/path", ["tip"]),
509
516
            split_segment_parameters_raw("/some,dir/path,tip"))
510
 
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
 
517
        self.assertEqual(("/somedir/path", ["heads%2Ftip"]),
511
518
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
512
 
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
 
519
        self.assertEqual(("/somedir/path", ["heads%2Ftip", "bar"]),
513
520
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
514
 
        self.assertEquals(("/", ["key1=val1"]),
 
521
        # Check relative references with relative paths
 
522
        self.assertEqual(("", ["key1=val1"]),
515
523
            split_segment_parameters_raw(",key1=val1"))
516
 
        self.assertEquals(("foo/", ["key1=val1"]),
 
524
        self.assertEqual(("foo/", ["key1=val1"]),
517
525
            split_segment_parameters_raw("foo/,key1=val1"))
518
 
        self.assertEquals(("/foo", ["key1=val1"]),
 
526
        self.assertEqual(("foo", ["key1=val1"]),
519
527
            split_segment_parameters_raw("foo,key1=val1"))
520
 
        self.assertEquals(("foo/base,la=bla/other/elements", []),
 
528
        self.assertEqual(("foo/base,la=bla/other/elements", []),
521
529
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
522
 
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
 
530
        self.assertEqual(("foo/base,la=bla/other/elements", ["a=b"]),
523
531
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
 
532
        # TODO: Check full URLs as well as relative references
524
533
 
525
534
    def test_split_segment_parameters(self):
526
535
        split_segment_parameters = urlutils.split_segment_parameters
527
 
        self.assertEquals(("/some/path", {}),
 
536
        # Check relative references with absolute paths
 
537
        self.assertEqual(("/some/path", {}),
528
538
            split_segment_parameters("/some/path"))
529
 
        self.assertEquals(("/some/path", {"branch": "tip"}),
 
539
        self.assertEqual(("/some/path", {"branch": "tip"}),
530
540
            split_segment_parameters("/some/path,branch=tip"))
531
 
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
 
541
        self.assertEqual(("/some,dir/path", {"branch": "tip"}),
532
542
            split_segment_parameters("/some,dir/path,branch=tip"))
533
 
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
 
543
        self.assertEqual(("/somedir/path", {"ref": "heads%2Ftip"}),
534
544
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
535
 
        self.assertEquals(("/somedir/path",
 
545
        self.assertEqual(("/somedir/path",
536
546
            {"ref": "heads%2Ftip", "key1": "val1"}),
537
547
            split_segment_parameters(
538
548
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
539
 
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
 
549
        self.assertEqual(("/somedir/path", {"ref": "heads%2F=tip"}),
540
550
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
541
 
        self.assertEquals(("/", {"key1": "val1"}),
 
551
        # Check relative references with relative paths
 
552
        self.assertEqual(("", {"key1": "val1"}),
542
553
            split_segment_parameters(",key1=val1"))
543
 
        self.assertEquals(("foo/", {"key1": "val1"}),
 
554
        self.assertEqual(("foo/", {"key1": "val1"}),
544
555
            split_segment_parameters("foo/,key1=val1"))
545
 
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
 
556
        self.assertEqual(("foo/base,key1=val1/other/elements", {}),
546
557
            split_segment_parameters("foo/base,key1=val1/other/elements"))
547
 
        self.assertEquals(("foo/base,key1=val1/other/elements",
 
558
        self.assertEqual(("foo/base,key1=val1/other/elements",
548
559
            {"key2": "val2"}), split_segment_parameters(
549
560
                "foo/base,key1=val1/other/elements,key2=val2"))
 
561
        # TODO: Check full URLs as well as relative references
550
562
 
551
563
    def test_win32_strip_local_trailing_slash(self):
552
564
        strip = urlutils._win32_strip_local_trailing_slash
714
726
 
715
727
 
716
728
class TestCwdToURL(TestCaseInTempDir):
717
 
    """Test that local_path_to_url works base on the cwd"""
 
729
    """Test that local_path_to_url works based on the cwd"""
718
730
 
719
731
    def test_dot(self):
720
732
        # This test will fail if getcwd is not ascii
818
830
 
819
831
    def test_parse_simple(self):
820
832
        parsed = urlutils.parse_url('http://example.com:80/one')
821
 
        self.assertEquals(('http', None, None, 'example.com', 80, '/one'),
 
833
        self.assertEqual(('http', None, None, 'example.com', 80, '/one'),
822
834
            parsed)
823
835
 
824
836
    def test_ipv6(self):
825
837
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
826
 
        self.assertEquals(('http', None, None, '1:2:3::40', None, '/one'),
 
838
        self.assertEqual(('http', None, None, '1:2:3::40', None, '/one'),
827
839
            parsed)
828
840
 
829
841
    def test_ipv6_port(self):
830
842
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
831
 
        self.assertEquals(('http', None, None, '1:2:3::40', 80, '/one'),
 
843
        self.assertEqual(('http', None, None, '1:2:3::40', 80, '/one'),
832
844
            parsed)
833
845
 
834
846
 
836
848
 
837
849
    def test_parse_simple(self):
838
850
        parsed = urlutils.URL.from_string('http://example.com:80/one')
839
 
        self.assertEquals('http', parsed.scheme)
 
851
        self.assertEqual('http', parsed.scheme)
840
852
        self.assertIs(None, parsed.user)
841
853
        self.assertIs(None, parsed.password)
842
 
        self.assertEquals('example.com', parsed.host)
843
 
        self.assertEquals(80, parsed.port)
844
 
        self.assertEquals('/one', parsed.path)
 
854
        self.assertEqual('example.com', parsed.host)
 
855
        self.assertEqual(80, parsed.port)
 
856
        self.assertEqual('/one', parsed.path)
845
857
 
846
858
    def test_ipv6(self):
847
859
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
848
 
        self.assertEquals('http', parsed.scheme)
 
860
        self.assertEqual('http', parsed.scheme)
849
861
        self.assertIs(None, parsed.port)
850
862
        self.assertIs(None, parsed.user)
851
863
        self.assertIs(None, parsed.password)
852
 
        self.assertEquals('1:2:3::40', parsed.host)
853
 
        self.assertEquals('/one', parsed.path)
 
864
        self.assertEqual('1:2:3::40', parsed.host)
 
865
        self.assertEqual('/one', parsed.path)
854
866
 
855
867
    def test_ipv6_port(self):
856
868
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
857
 
        self.assertEquals('http', parsed.scheme)
858
 
        self.assertEquals('1:2:3::40', parsed.host)
 
869
        self.assertEqual('http', parsed.scheme)
 
870
        self.assertEqual('1:2:3::40', parsed.host)
859
871
        self.assertIs(None, parsed.user)
860
872
        self.assertIs(None, parsed.password)
861
 
        self.assertEquals(80, parsed.port)
862
 
        self.assertEquals('/one', parsed.path)
 
873
        self.assertEqual(80, parsed.port)
 
874
        self.assertEqual('/one', parsed.path)
863
875
 
864
876
    def test_quoted(self):
865
877
        parsed = urlutils.URL.from_string(
866
878
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
867
 
        self.assertEquals(parsed.quoted_host, 'ex%41mple.com')
868
 
        self.assertEquals(parsed.host, 'exAmple.com')
869
 
        self.assertEquals(parsed.port, 2222)
870
 
        self.assertEquals(parsed.quoted_user, 'ro%62ey')
871
 
        self.assertEquals(parsed.user, 'robey')
872
 
        self.assertEquals(parsed.quoted_password, 'h%40t')
873
 
        self.assertEquals(parsed.password, 'h@t')
874
 
        self.assertEquals(parsed.path, '/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')
875
887
 
876
888
    def test_eq(self):
877
889
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
878
890
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
879
 
        self.assertEquals(parsed1, parsed2)
880
 
        self.assertEquals(parsed1, parsed1)
 
891
        self.assertEqual(parsed1, parsed2)
 
892
        self.assertEqual(parsed1, parsed1)
881
893
        parsed2.path = '/two'
882
 
        self.assertNotEquals(parsed1, parsed2)
 
894
        self.assertNotEqual(parsed1, parsed2)
883
895
 
884
896
    def test_repr(self):
885
897
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
886
 
        self.assertEquals(
 
898
        self.assertEqual(
887
899
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
888
900
            repr(parsed))
889
901
 
890
902
    def test_str(self):
891
903
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
892
 
        self.assertEquals('http://[1:2:3::40]:80/one', str(parsed))
 
904
        self.assertEqual('http://[1:2:3::40]:80/one', str(parsed))
893
905
 
894
906
    def test__combine_paths(self):
895
907
        combine = urlutils.URL._combine_paths
905
917
    def test_clone(self):
906
918
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
907
919
        url1 = url.clone("two")
908
 
        self.assertEquals("/one/two", url1.path)
 
920
        self.assertEqual("/one/two", url1.path)
909
921
        url2 = url.clone("/two")
910
 
        self.assertEquals("/two", url2.path)
 
922
        self.assertEqual("/two", url2.path)
911
923
        url3 = url.clone()
912
924
        self.assertIsNot(url, url3)
913
 
        self.assertEquals(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'))