← 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: Ross Lagerwall
  • Date: 2012-08-07 06:32:51 UTC
  • mto: (6437.63.5 2.5)
  • mto: This revision was merged to the branch mainline in revision 6558.
  • Revision ID: rosslagerwall@gmail.com-20120807063251-x9p03ghg2ws8oqjc
Add bzrlib/locale to .bzrignore

bzrlib/locale is generated with ./setup.py build_mo which is in turn called
by ./setup.py build

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