← 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: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2006-2012 Canonical Ltd
 
1
# Copyright (C) 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
26
26
    InvalidRebaseURLs,
27
27
    PathNotChild,
28
28
    )
29
 
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
 
29
from bzrlib.tests import features, TestCaseInTempDir, TestCase, TestSkipped
30
30
 
31
31
 
32
32
class TestUrlToPath(TestCase):
296
296
 
297
297
    def test_join_segment_parameters_raw(self):
298
298
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
299
 
        self.assertEquals("/somedir/path", 
 
299
        self.assertEqual("/somedir/path", 
300
300
            join_segment_parameters_raw("/somedir/path"))
301
 
        self.assertEquals("/somedir/path,rawdata", 
 
301
        self.assertEqual("/somedir/path,rawdata", 
302
302
            join_segment_parameters_raw("/somedir/path", "rawdata"))
303
303
        self.assertRaises(InvalidURLJoin,
304
304
            join_segment_parameters_raw, "/somedir/path",
305
305
                "rawdata1,rawdata2,rawdata3")
306
 
        self.assertEquals("/somedir/path,bla,bar",
 
306
        self.assertEqual("/somedir/path,bla,bar",
307
307
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
308
 
        self.assertEquals("/somedir,exist=some/path,bla,bar",
 
308
        self.assertEqual("/somedir,exist=some/path,bla,bar",
309
309
            join_segment_parameters_raw("/somedir,exist=some/path",
310
310
                "bla", "bar"))
311
311
        self.assertRaises(TypeError, join_segment_parameters_raw, 
313
313
 
314
314
    def test_join_segment_parameters(self):
315
315
        join_segment_parameters = urlutils.join_segment_parameters
316
 
        self.assertEquals("/somedir/path", 
 
316
        self.assertEqual("/somedir/path", 
317
317
            join_segment_parameters("/somedir/path", {}))
318
 
        self.assertEquals("/somedir/path,key1=val1", 
 
318
        self.assertEqual("/somedir/path,key1=val1", 
319
319
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
320
320
        self.assertRaises(InvalidURLJoin,
321
321
            join_segment_parameters, "/somedir/path",
322
322
            {"branch": "brr,brr,brr"})
323
323
        self.assertRaises(InvalidURLJoin,
324
324
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
325
 
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
325
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
326
326
            join_segment_parameters("/somedir/path", {
327
327
                "key1": "val1", "key2": "val2"}))
328
 
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
328
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
329
329
            join_segment_parameters("/somedir/path,key1=val1", {
330
330
                "key2": "val2"}))
331
 
        self.assertEquals("/somedir/path,key1=val2",
 
331
        self.assertEqual("/somedir/path,key1=val2",
332
332
            join_segment_parameters("/somedir/path,key1=val1", {
333
333
                "key1": "val2"}))
334
 
        self.assertEquals("/somedir,exist=some/path,key1=val1",
 
334
        self.assertEqual("/somedir,exist=some/path,key1=val1",
335
335
            join_segment_parameters("/somedir,exist=some/path",
336
336
                {"key1": "val1"}))
337
 
        self.assertEquals("/,key1=val1,key2=val2",
 
337
        self.assertEqual("/,key1=val1,key2=val2",
338
338
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
339
339
        self.assertRaises(TypeError,
340
340
            join_segment_parameters, "/,key1=val1", {"foo": 42})
411
411
        self.assertFalse(isinstance(result, unicode))
412
412
 
413
413
    def test_win32_unc_path_to_url(self):
 
414
        self.requireFeature(features.win32_feature)
414
415
        to_url = urlutils._win32_local_path_to_url
415
416
        self.assertEqual('file://HOST/path',
416
417
            to_url(r'\\HOST\path'))
507
508
    def test_split_segment_parameters_raw(self):
508
509
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
509
510
        # Check relative references with absolute paths
510
 
        self.assertEquals(("/some/path", []),
 
511
        self.assertEqual(("/some/path", []),
511
512
            split_segment_parameters_raw("/some/path"))
512
 
        self.assertEquals(("/some/path", ["tip"]),
 
513
        self.assertEqual(("/some/path", ["tip"]),
513
514
            split_segment_parameters_raw("/some/path,tip"))
514
 
        self.assertEquals(("/some,dir/path", ["tip"]),
 
515
        self.assertEqual(("/some,dir/path", ["tip"]),
515
516
            split_segment_parameters_raw("/some,dir/path,tip"))
516
 
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
 
517
        self.assertEqual(("/somedir/path", ["heads%2Ftip"]),
517
518
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
518
 
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
 
519
        self.assertEqual(("/somedir/path", ["heads%2Ftip", "bar"]),
519
520
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
520
521
        # Check relative references with relative paths
521
 
        self.assertEquals(("", ["key1=val1"]),
 
522
        self.assertEqual(("", ["key1=val1"]),
522
523
            split_segment_parameters_raw(",key1=val1"))
523
 
        self.assertEquals(("foo/", ["key1=val1"]),
 
524
        self.assertEqual(("foo/", ["key1=val1"]),
524
525
            split_segment_parameters_raw("foo/,key1=val1"))
525
 
        self.assertEquals(("foo", ["key1=val1"]),
 
526
        self.assertEqual(("foo", ["key1=val1"]),
526
527
            split_segment_parameters_raw("foo,key1=val1"))
527
 
        self.assertEquals(("foo/base,la=bla/other/elements", []),
 
528
        self.assertEqual(("foo/base,la=bla/other/elements", []),
528
529
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
529
 
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
 
530
        self.assertEqual(("foo/base,la=bla/other/elements", ["a=b"]),
530
531
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
531
532
        # TODO: Check full URLs as well as relative references
532
533
 
533
534
    def test_split_segment_parameters(self):
534
535
        split_segment_parameters = urlutils.split_segment_parameters
535
536
        # Check relative references with absolute paths
536
 
        self.assertEquals(("/some/path", {}),
 
537
        self.assertEqual(("/some/path", {}),
537
538
            split_segment_parameters("/some/path"))
538
 
        self.assertEquals(("/some/path", {"branch": "tip"}),
 
539
        self.assertEqual(("/some/path", {"branch": "tip"}),
539
540
            split_segment_parameters("/some/path,branch=tip"))
540
 
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
 
541
        self.assertEqual(("/some,dir/path", {"branch": "tip"}),
541
542
            split_segment_parameters("/some,dir/path,branch=tip"))
542
 
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
 
543
        self.assertEqual(("/somedir/path", {"ref": "heads%2Ftip"}),
543
544
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
544
 
        self.assertEquals(("/somedir/path",
 
545
        self.assertEqual(("/somedir/path",
545
546
            {"ref": "heads%2Ftip", "key1": "val1"}),
546
547
            split_segment_parameters(
547
548
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
548
 
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
 
549
        self.assertEqual(("/somedir/path", {"ref": "heads%2F=tip"}),
549
550
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
550
551
        # Check relative references with relative paths
551
 
        self.assertEquals(("", {"key1": "val1"}),
 
552
        self.assertEqual(("", {"key1": "val1"}),
552
553
            split_segment_parameters(",key1=val1"))
553
 
        self.assertEquals(("foo/", {"key1": "val1"}),
 
554
        self.assertEqual(("foo/", {"key1": "val1"}),
554
555
            split_segment_parameters("foo/,key1=val1"))
555
 
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
 
556
        self.assertEqual(("foo/base,key1=val1/other/elements", {}),
556
557
            split_segment_parameters("foo/base,key1=val1/other/elements"))
557
 
        self.assertEquals(("foo/base,key1=val1/other/elements",
 
558
        self.assertEqual(("foo/base,key1=val1/other/elements",
558
559
            {"key2": "val2"}), split_segment_parameters(
559
560
                "foo/base,key1=val1/other/elements,key2=val2"))
560
561
        # TODO: Check full URLs as well as relative references
829
830
 
830
831
    def test_parse_simple(self):
831
832
        parsed = urlutils.parse_url('http://example.com:80/one')
832
 
        self.assertEquals(('http', None, None, 'example.com', 80, '/one'),
 
833
        self.assertEqual(('http', None, None, 'example.com', 80, '/one'),
833
834
            parsed)
834
835
 
835
836
    def test_ipv6(self):
836
837
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
837
 
        self.assertEquals(('http', None, None, '1:2:3::40', None, '/one'),
 
838
        self.assertEqual(('http', None, None, '1:2:3::40', None, '/one'),
838
839
            parsed)
839
840
 
840
841
    def test_ipv6_port(self):
841
842
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
842
 
        self.assertEquals(('http', None, None, '1:2:3::40', 80, '/one'),
 
843
        self.assertEqual(('http', None, None, '1:2:3::40', 80, '/one'),
843
844
            parsed)
844
845
 
845
846
 
847
848
 
848
849
    def test_parse_simple(self):
849
850
        parsed = urlutils.URL.from_string('http://example.com:80/one')
850
 
        self.assertEquals('http', parsed.scheme)
 
851
        self.assertEqual('http', parsed.scheme)
851
852
        self.assertIs(None, parsed.user)
852
853
        self.assertIs(None, parsed.password)
853
 
        self.assertEquals('example.com', parsed.host)
854
 
        self.assertEquals(80, parsed.port)
855
 
        self.assertEquals('/one', parsed.path)
 
854
        self.assertEqual('example.com', parsed.host)
 
855
        self.assertEqual(80, parsed.port)
 
856
        self.assertEqual('/one', parsed.path)
856
857
 
857
858
    def test_ipv6(self):
858
859
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
859
 
        self.assertEquals('http', parsed.scheme)
 
860
        self.assertEqual('http', parsed.scheme)
860
861
        self.assertIs(None, parsed.port)
861
862
        self.assertIs(None, parsed.user)
862
863
        self.assertIs(None, parsed.password)
863
 
        self.assertEquals('1:2:3::40', parsed.host)
864
 
        self.assertEquals('/one', parsed.path)
 
864
        self.assertEqual('1:2:3::40', parsed.host)
 
865
        self.assertEqual('/one', parsed.path)
865
866
 
866
867
    def test_ipv6_port(self):
867
868
        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)
 
869
        self.assertEqual('http', parsed.scheme)
 
870
        self.assertEqual('1:2:3::40', parsed.host)
870
871
        self.assertIs(None, parsed.user)
871
872
        self.assertIs(None, parsed.password)
872
 
        self.assertEquals(80, parsed.port)
873
 
        self.assertEquals('/one', parsed.path)
 
873
        self.assertEqual(80, parsed.port)
 
874
        self.assertEqual('/one', parsed.path)
874
875
 
875
876
    def test_quoted(self):
876
877
        parsed = urlutils.URL.from_string(
877
878
            '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')
 
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')
886
887
 
887
888
    def test_eq(self):
888
889
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
889
890
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
890
 
        self.assertEquals(parsed1, parsed2)
891
 
        self.assertEquals(parsed1, parsed1)
 
891
        self.assertEqual(parsed1, parsed2)
 
892
        self.assertEqual(parsed1, parsed1)
892
893
        parsed2.path = '/two'
893
 
        self.assertNotEquals(parsed1, parsed2)
 
894
        self.assertNotEqual(parsed1, parsed2)
894
895
 
895
896
    def test_repr(self):
896
897
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
897
 
        self.assertEquals(
 
898
        self.assertEqual(
898
899
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
899
900
            repr(parsed))
900
901
 
901
902
    def test_str(self):
902
903
        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
        self.assertEqual('http://[1:2:3::40]:80/one', str(parsed))
904
905
 
905
906
    def test__combine_paths(self):
906
907
        combine = urlutils.URL._combine_paths
916
917
    def test_clone(self):
917
918
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
918
919
        url1 = url.clone("two")
919
 
        self.assertEquals("/one/two", url1.path)
 
920
        self.assertEqual("/one/two", url1.path)
920
921
        url2 = url.clone("/two")
921
 
        self.assertEquals("/two", url2.path)
 
922
        self.assertEqual("/two", url2.path)
922
923
        url3 = url.clone()
923
924
        self.assertIsNot(url, url3)
924
 
        self.assertEquals(url, url3)
 
925
        self.assertEqual(url, url3)
925
926
 
926
927
 
927
928
class TestFileRelpath(TestCase):
953
954
 
954
955
    def test_same_url_posix(self):
955
956
        self._with_posix_paths()
956
 
        self.assertEquals("",
 
957
        self.assertEqual("",
957
958
            urlutils.file_relpath("file:///a", "file:///a"))
958
 
        self.assertEquals("",
 
959
        self.assertEqual("",
959
960
            urlutils.file_relpath("file:///a", "file:///a/"))
960
 
        self.assertEquals("",
 
961
        self.assertEqual("",
961
962
            urlutils.file_relpath("file:///a/", "file:///a"))
962
963
 
963
964
    def test_same_url_win32(self):
964
965
        self._with_win32_paths()
965
 
        self.assertEquals("",
 
966
        self.assertEqual("",
966
967
            urlutils.file_relpath("file:///A:/", "file:///A:/"))
967
 
        self.assertEquals("",
 
968
        self.assertEqual("",
968
969
            urlutils.file_relpath("file:///A|/", "file:///A:/"))
969
 
        self.assertEquals("",
 
970
        self.assertEqual("",
970
971
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
971
 
        self.assertEquals("",
 
972
        self.assertEqual("",
972
973
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
973
 
        self.assertEquals("",
 
974
        self.assertEqual("",
974
975
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
975
976
 
976
977
    def test_child_posix(self):
977
978
        self._with_posix_paths()
978
 
        self.assertEquals("b",
 
979
        self.assertEqual("b",
979
980
            urlutils.file_relpath("file:///a", "file:///a/b"))
980
 
        self.assertEquals("b",
 
981
        self.assertEqual("b",
981
982
            urlutils.file_relpath("file:///a/", "file:///a/b"))
982
 
        self.assertEquals("b/c",
 
983
        self.assertEqual("b/c",
983
984
            urlutils.file_relpath("file:///a", "file:///a/b/c"))
984
985
 
985
986
    def test_child_win32(self):
986
987
        self._with_win32_paths()
987
 
        self.assertEquals("b",
 
988
        self.assertEqual("b",
988
989
            urlutils.file_relpath("file:///A:/", "file:///A:/b"))
989
 
        self.assertEquals("b",
 
990
        self.assertEqual("b",
990
991
            urlutils.file_relpath("file:///A|/", "file:///A:/b"))
991
 
        self.assertEquals("c",
 
992
        self.assertEqual("c",
992
993
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
993
 
        self.assertEquals("c",
 
994
        self.assertEqual("c",
994
995
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
995
 
        self.assertEquals("c/d",
 
996
        self.assertEqual("c/d",
996
997
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
997
998
 
998
999
    def test_sibling_posix(self):