← 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: Canonical.com Patch Queue Manager
  • Date: 2011-06-30 18:28:17 UTC
  • mfrom: (5967.10.2 test-cat)
  • Revision ID: pqm@pqm.ubuntu.com-20110630182817-83a5q9r9rxfkdn8r
(mbp) don't use subprocesses for testing cat (Martin Pool)

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