← 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: Martin von Gagern
  • Date: 2011-06-01 12:53:56 UTC
  • mto: This revision was merged to the branch mainline in revision 6009.
  • Revision ID: martin.vgagern@gmx.net-20110601125356-lwozv2vecea6hxfz
Change from no_decorate to classify as name for the argument.

The command line switch remains as --no-classify, to keep backwards
compatibility.  Users are free to include --no-classify in an alias, and
still use --classify to change back.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
336
336
 
337
337
    def test_function_type(self):
338
338
        if sys.platform == 'win32':
339
 
            self.assertEqual(urlutils._win32_local_path_to_url,
340
 
                urlutils.local_path_to_url)
341
 
            self.assertEqual(urlutils._win32_local_path_from_url,
342
 
                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)
343
341
        else:
344
 
            self.assertEqual(urlutils._posix_local_path_to_url,
345
 
                urlutils.local_path_to_url)
346
 
            self.assertEqual(urlutils._posix_local_path_from_url,
347
 
                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)
348
344
 
349
345
    def test_posix_local_path_to_url(self):
350
346
        to_url = urlutils._posix_local_path_to_url
351
347
        self.assertEqual('file:///path/to/foo',
352
348
            to_url('/path/to/foo'))
353
349
 
354
 
        self.assertEqual('file:///path/to/foo%2Cbar',
355
 
            to_url('/path/to/foo,bar'))
356
 
 
357
350
        try:
358
351
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
359
352
        except UnicodeError:
366
359
        from_url = urlutils._posix_local_path_from_url
367
360
        self.assertEqual('/path/to/foo',
368
361
            from_url('file:///path/to/foo'))
369
 
        self.assertEqual('/path/to/foo',
370
 
            from_url('file:///path/to/foo,branch=foo'))
371
362
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
372
363
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
373
364
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
395
386
 
396
387
        self.assertEqual('file:///', to_url('/'))
397
388
 
398
 
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
399
 
            to_url('C:/path/to/foo,bar'))
400
389
        try:
401
390
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
402
391
        except UnicodeError:
429
418
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
430
419
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
431
420
        self.assertEqual('/', from_url('file:///'))
432
 
        self.assertEqual('C:/path/to/foo',
433
 
            from_url('file:///C|/path/to/foo,branch=foo'))
434
421
 
435
422
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
436
423
        self.assertRaises(InvalidURL, from_url, 'file:///c')
441
428
    def test_win32_unc_path_from_url(self):
442
429
        from_url = urlutils._win32_local_path_from_url
443
430
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
444
 
        self.assertEqual('//HOST/path',
445
 
            from_url('file://HOST/path,branch=foo'))
446
431
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
447
432
        # we want to use only 2 slashes
448
433
        # Firefox understand only 5 slashes in URL, but it's ugly
457
442
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
458
443
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
459
444
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
460
 
        # Root drives without slash treated as invalid, see bug #841322
461
 
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
462
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C:')
463
 
        # Invalid without drive separator or following forward slash
464
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C')
465
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C:ool')
466
445
 
467
446
    def test_split(self):
468
447
        # Test bzrlib.urlutils.split()
515
494
            split_segment_parameters_raw(",key1=val1"))
516
495
        self.assertEquals(("foo/", ["key1=val1"]),
517
496
            split_segment_parameters_raw("foo/,key1=val1"))
518
 
        self.assertEquals(("/foo", ["key1=val1"]),
519
 
            split_segment_parameters_raw("foo,key1=val1"))
520
497
        self.assertEquals(("foo/base,la=bla/other/elements", []),
521
498
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
522
499
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
816
793
 
817
794
class TestParseURL(TestCase):
818
795
 
819
 
    def test_parse_simple(self):
820
 
        parsed = urlutils.parse_url('http://example.com:80/one')
821
 
        self.assertEquals(('http', None, None, 'example.com', 80, '/one'),
822
 
            parsed)
823
 
 
824
 
    def test_ipv6(self):
825
 
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
826
 
        self.assertEquals(('http', None, None, '1:2:3::40', None, '/one'),
827
 
            parsed)
828
 
 
829
 
    def test_ipv6_port(self):
830
 
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
831
 
        self.assertEquals(('http', None, None, '1:2:3::40', 80, '/one'),
832
 
            parsed)
833
 
 
834
 
 
835
 
class TestURL(TestCase):
836
 
 
837
 
    def test_parse_simple(self):
838
 
        parsed = urlutils.URL.from_string('http://example.com:80/one')
839
 
        self.assertEquals('http', parsed.scheme)
840
 
        self.assertIs(None, parsed.user)
841
 
        self.assertIs(None, parsed.password)
842
 
        self.assertEquals('example.com', parsed.host)
843
 
        self.assertEquals(80, parsed.port)
844
 
        self.assertEquals('/one', parsed.path)
845
 
 
846
 
    def test_ipv6(self):
847
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
848
 
        self.assertEquals('http', parsed.scheme)
849
 
        self.assertIs(None, parsed.port)
850
 
        self.assertIs(None, parsed.user)
851
 
        self.assertIs(None, parsed.password)
852
 
        self.assertEquals('1:2:3::40', parsed.host)
853
 
        self.assertEquals('/one', parsed.path)
854
 
 
855
 
    def test_ipv6_port(self):
856
 
        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)
859
 
        self.assertIs(None, parsed.user)
860
 
        self.assertIs(None, parsed.password)
861
 
        self.assertEquals(80, parsed.port)
862
 
        self.assertEquals('/one', parsed.path)
863
 
 
864
 
    def test_quoted(self):
865
 
        parsed = urlutils.URL.from_string(
866
 
            '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')
875
 
 
876
 
    def test_eq(self):
877
 
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
878
 
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
879
 
        self.assertEquals(parsed1, parsed2)
880
 
        self.assertEquals(parsed1, parsed1)
881
 
        parsed2.path = '/two'
882
 
        self.assertNotEquals(parsed1, parsed2)
883
 
 
884
 
    def test_repr(self):
885
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
886
 
        self.assertEquals(
887
 
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
888
 
            repr(parsed))
889
 
 
890
 
    def test_str(self):
891
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
892
 
        self.assertEquals('http://[1:2:3::40]:80/one', str(parsed))
893
 
 
894
 
    def test__combine_paths(self):
895
 
        combine = urlutils.URL._combine_paths
896
 
        self.assertEqual('/home/sarah/project/foo',
897
 
                         combine('/home/sarah', 'project/foo'))
898
 
        self.assertEqual('/etc',
899
 
                         combine('/home/sarah', '../../etc'))
900
 
        self.assertEqual('/etc',
901
 
                         combine('/home/sarah', '../../../etc'))
902
 
        self.assertEqual('/etc',
903
 
                         combine('/home/sarah', '/etc'))
904
 
 
905
 
    def test_clone(self):
906
 
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
907
 
        url1 = url.clone("two")
908
 
        self.assertEquals("/one/two", url1.path)
909
 
        url2 = url.clone("/two")
910
 
        self.assertEquals("/two", url2.path)
911
 
        url3 = url.clone()
912
 
        self.assertIsNot(url, url3)
913
 
        self.assertEquals(url, url3)
 
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'))