/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

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, 2015 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
19
19
import os
20
20
import sys
21
21
 
22
 
from .. import osutils, urlutils, win32utils
23
 
from ..errors import (
 
22
from bzrlib import osutils, urlutils, win32utils
 
23
from bzrlib.errors import (
 
24
    InvalidURL,
 
25
    InvalidURLJoin,
 
26
    InvalidRebaseURLs,
24
27
    PathNotChild,
25
28
    )
26
 
from . import features, TestCaseInTempDir, TestCase, TestSkipped
 
29
from bzrlib.tests import features, TestCaseInTempDir, TestCase, TestSkipped
27
30
 
28
31
 
29
32
class TestUrlToPath(TestCase):
30
33
 
31
34
    def test_basename(self):
32
 
        # breezy.urlutils.basename
33
 
        # Test breezy.urlutils.split()
 
35
        # bzrlib.urlutils.basename
 
36
        # Test bzrlib.urlutils.split()
34
37
        basename = urlutils.basename
35
38
        if sys.platform == 'win32':
36
 
            self.assertRaises(urlutils.InvalidURL, basename,
37
 
                    'file:///path/to/foo')
 
39
            self.assertRaises(InvalidURL, basename, 'file:///path/to/foo')
38
40
            self.assertEqual('foo', basename('file:///C|/foo'))
39
41
            self.assertEqual('foo', basename('file:///C:/foo'))
40
42
            self.assertEqual('', basename('file:///C:/'))
124
126
 
125
127
        # Normalize verifies URLs when they are not unicode
126
128
        # (indicating they did not come from the user)
127
 
        self.assertRaises(urlutils.InvalidURL, normalize_url,
128
 
                'http://host/\xb5')
129
 
        self.assertRaises(urlutils.InvalidURL, normalize_url, 'http://host/ ')
 
129
        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
 
130
        self.assertRaises(InvalidURL, normalize_url, 'http://host/ ')
130
131
 
131
132
    def test_url_scheme_re(self):
132
133
        # Test paths that may be URLs
166
167
        test_one('ab://foo', ('ab', 'foo'))
167
168
 
168
169
    def test_dirname(self):
169
 
        # Test breezy.urlutils.dirname()
 
170
        # Test bzrlib.urlutils.dirname()
170
171
        dirname = urlutils.dirname
171
172
        if sys.platform == 'win32':
172
 
            self.assertRaises(urlutils.InvalidURL, dirname,
173
 
                'file:///path/to/foo')
 
173
            self.assertRaises(InvalidURL, dirname, 'file:///path/to/foo')
174
174
            self.assertEqual('file:///C|/', dirname('file:///C|/foo'))
175
175
            self.assertEqual('file:///C|/', dirname('file:///C|/'))
176
176
        else:
253
253
        # Invalid joinings
254
254
        # Cannot go above root
255
255
        # Implicitly at root:
256
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
 
256
        self.assertRaises(InvalidURLJoin, urlutils.join,
257
257
                'http://foo', '../baz')
258
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
 
258
        self.assertRaises(InvalidURLJoin, urlutils.join,
259
259
                'http://foo', '/..')
260
260
        # Joining from a path explicitly under the root.
261
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
 
261
        self.assertRaises(InvalidURLJoin, urlutils.join,
262
262
                'http://foo/a', '../../b')
263
263
 
264
264
    def test_joinpath(self):
290
290
 
291
291
        # Invalid joinings
292
292
        # Cannot go above root
293
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
294
 
                '../baz')
295
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
296
 
                '..')
297
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
298
 
                '/..')
 
293
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
 
294
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
 
295
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
299
296
 
300
297
    def test_join_segment_parameters_raw(self):
301
298
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
302
 
        self.assertEqual("/somedir/path", 
 
299
        self.assertEquals("/somedir/path", 
303
300
            join_segment_parameters_raw("/somedir/path"))
304
 
        self.assertEqual("/somedir/path,rawdata", 
 
301
        self.assertEquals("/somedir/path,rawdata", 
305
302
            join_segment_parameters_raw("/somedir/path", "rawdata"))
306
 
        self.assertRaises(urlutils.InvalidURLJoin,
 
303
        self.assertRaises(InvalidURLJoin,
307
304
            join_segment_parameters_raw, "/somedir/path",
308
305
                "rawdata1,rawdata2,rawdata3")
309
 
        self.assertEqual("/somedir/path,bla,bar",
 
306
        self.assertEquals("/somedir/path,bla,bar",
310
307
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
311
 
        self.assertEqual("/somedir,exist=some/path,bla,bar",
 
308
        self.assertEquals("/somedir,exist=some/path,bla,bar",
312
309
            join_segment_parameters_raw("/somedir,exist=some/path",
313
310
                "bla", "bar"))
314
311
        self.assertRaises(TypeError, join_segment_parameters_raw, 
316
313
 
317
314
    def test_join_segment_parameters(self):
318
315
        join_segment_parameters = urlutils.join_segment_parameters
319
 
        self.assertEqual("/somedir/path", 
 
316
        self.assertEquals("/somedir/path", 
320
317
            join_segment_parameters("/somedir/path", {}))
321
 
        self.assertEqual("/somedir/path,key1=val1", 
 
318
        self.assertEquals("/somedir/path,key1=val1", 
322
319
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
323
 
        self.assertRaises(urlutils.InvalidURLJoin,
 
320
        self.assertRaises(InvalidURLJoin,
324
321
            join_segment_parameters, "/somedir/path",
325
322
            {"branch": "brr,brr,brr"})
326
 
        self.assertRaises(urlutils.InvalidURLJoin,
 
323
        self.assertRaises(InvalidURLJoin,
327
324
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
328
 
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
 
325
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
329
326
            join_segment_parameters("/somedir/path", {
330
327
                "key1": "val1", "key2": "val2"}))
331
 
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
 
328
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
332
329
            join_segment_parameters("/somedir/path,key1=val1", {
333
330
                "key2": "val2"}))
334
 
        self.assertEqual("/somedir/path,key1=val2",
 
331
        self.assertEquals("/somedir/path,key1=val2",
335
332
            join_segment_parameters("/somedir/path,key1=val1", {
336
333
                "key1": "val2"}))
337
 
        self.assertEqual("/somedir,exist=some/path,key1=val1",
 
334
        self.assertEquals("/somedir,exist=some/path,key1=val1",
338
335
            join_segment_parameters("/somedir,exist=some/path",
339
336
                {"key1": "val1"}))
340
 
        self.assertEqual("/,key1=val1,key2=val2",
 
337
        self.assertEquals("/,key1=val1,key2=val2",
341
338
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
342
339
        self.assertRaises(TypeError,
343
340
            join_segment_parameters, "/,key1=val1", {"foo": 42})
383
380
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
384
381
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
385
382
 
386
 
        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
 
383
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
387
384
        self.assertRaises(
388
 
            urlutils.InvalidURL, from_url,
 
385
            InvalidURL, from_url,
389
386
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
390
387
 
391
388
    def test_win32_local_path_to_url(self):
441
438
        self.assertEqual('C:/path/to/foo',
442
439
            from_url('file:///C|/path/to/foo,branch=foo'))
443
440
 
444
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///C:')
445
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///c')
446
 
        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
 
441
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
 
442
        self.assertRaises(InvalidURL, from_url, 'file:///c')
 
443
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
447
444
        # Not a valid _win32 url, no drive letter
448
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///path/to/foo')
 
445
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
449
446
 
450
447
    def test_win32_unc_path_from_url(self):
451
448
        from_url = urlutils._win32_local_path_from_url
455
452
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
456
453
        # we want to use only 2 slashes
457
454
        # Firefox understand only 5 slashes in URL, but it's ugly
458
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:////HOST/path')
459
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://///HOST/path')
460
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://////HOST/path')
 
455
        self.assertRaises(InvalidURL, from_url, 'file:////HOST/path')
 
456
        self.assertRaises(InvalidURL, from_url, 'file://///HOST/path')
 
457
        self.assertRaises(InvalidURL, from_url, 'file://////HOST/path')
461
458
        # check for file://C:/ instead of file:///C:/
462
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://C:/path')
 
459
        self.assertRaises(InvalidURL, from_url, 'file://C:/path')
463
460
 
464
461
    def test_win32_extract_drive_letter(self):
465
462
        extract = urlutils._win32_extract_drive_letter
466
463
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
467
464
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
468
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/path')
 
465
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
469
466
        # Root drives without slash treated as invalid, see bug #841322
470
467
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
471
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:')
 
468
        self.assertRaises(InvalidURL, extract, 'file://', '/C:')
472
469
        # Invalid without drive separator or following forward slash
473
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C')
474
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:ool')
 
470
        self.assertRaises(InvalidURL, extract, 'file://', '/C')
 
471
        self.assertRaises(InvalidURL, extract, 'file://', '/C:ool')
475
472
 
476
473
    def test_split(self):
477
 
        # Test breezy.urlutils.split()
 
474
        # Test bzrlib.urlutils.split()
478
475
        split = urlutils.split
479
476
        if sys.platform == 'win32':
480
 
            self.assertRaises(urlutils.InvalidURL, split, 'file:///path/to/foo')
 
477
            self.assertRaises(InvalidURL, split, 'file:///path/to/foo')
481
478
            self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))
482
479
            self.assertEqual(('file:///C:/', ''), split('file:///C:/'))
483
480
        else:
511
508
    def test_split_segment_parameters_raw(self):
512
509
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
513
510
        # Check relative references with absolute paths
514
 
        self.assertEqual(("/some/path", []),
 
511
        self.assertEquals(("/some/path", []),
515
512
            split_segment_parameters_raw("/some/path"))
516
 
        self.assertEqual(("/some/path", ["tip"]),
 
513
        self.assertEquals(("/some/path", ["tip"]),
517
514
            split_segment_parameters_raw("/some/path,tip"))
518
 
        self.assertEqual(("/some,dir/path", ["tip"]),
 
515
        self.assertEquals(("/some,dir/path", ["tip"]),
519
516
            split_segment_parameters_raw("/some,dir/path,tip"))
520
 
        self.assertEqual(("/somedir/path", ["heads%2Ftip"]),
 
517
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
521
518
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
522
 
        self.assertEqual(("/somedir/path", ["heads%2Ftip", "bar"]),
 
519
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
523
520
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
524
521
        # Check relative references with relative paths
525
 
        self.assertEqual(("", ["key1=val1"]),
 
522
        self.assertEquals(("", ["key1=val1"]),
526
523
            split_segment_parameters_raw(",key1=val1"))
527
 
        self.assertEqual(("foo/", ["key1=val1"]),
 
524
        self.assertEquals(("foo/", ["key1=val1"]),
528
525
            split_segment_parameters_raw("foo/,key1=val1"))
529
 
        self.assertEqual(("foo", ["key1=val1"]),
 
526
        self.assertEquals(("foo", ["key1=val1"]),
530
527
            split_segment_parameters_raw("foo,key1=val1"))
531
 
        self.assertEqual(("foo/base,la=bla/other/elements", []),
 
528
        self.assertEquals(("foo/base,la=bla/other/elements", []),
532
529
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
533
 
        self.assertEqual(("foo/base,la=bla/other/elements", ["a=b"]),
 
530
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
534
531
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
535
532
        # TODO: Check full URLs as well as relative references
536
533
 
537
534
    def test_split_segment_parameters(self):
538
535
        split_segment_parameters = urlutils.split_segment_parameters
539
536
        # Check relative references with absolute paths
540
 
        self.assertEqual(("/some/path", {}),
 
537
        self.assertEquals(("/some/path", {}),
541
538
            split_segment_parameters("/some/path"))
542
 
        self.assertEqual(("/some/path", {"branch": "tip"}),
 
539
        self.assertEquals(("/some/path", {"branch": "tip"}),
543
540
            split_segment_parameters("/some/path,branch=tip"))
544
 
        self.assertEqual(("/some,dir/path", {"branch": "tip"}),
 
541
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
545
542
            split_segment_parameters("/some,dir/path,branch=tip"))
546
 
        self.assertEqual(("/somedir/path", {"ref": "heads%2Ftip"}),
 
543
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
547
544
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
548
 
        self.assertEqual(("/somedir/path",
 
545
        self.assertEquals(("/somedir/path",
549
546
            {"ref": "heads%2Ftip", "key1": "val1"}),
550
547
            split_segment_parameters(
551
548
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
552
 
        self.assertEqual(("/somedir/path", {"ref": "heads%2F=tip"}),
 
549
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
553
550
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
554
551
        # Check relative references with relative paths
555
 
        self.assertEqual(("", {"key1": "val1"}),
 
552
        self.assertEquals(("", {"key1": "val1"}),
556
553
            split_segment_parameters(",key1=val1"))
557
 
        self.assertEqual(("foo/", {"key1": "val1"}),
 
554
        self.assertEquals(("foo/", {"key1": "val1"}),
558
555
            split_segment_parameters("foo/,key1=val1"))
559
 
        self.assertEqual(("foo/base,key1=val1/other/elements", {}),
 
556
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
560
557
            split_segment_parameters("foo/base,key1=val1/other/elements"))
561
 
        self.assertEqual(("foo/base,key1=val1/other/elements",
 
558
        self.assertEquals(("foo/base,key1=val1/other/elements",
562
559
            {"key2": "val2"}), split_segment_parameters(
563
560
                "foo/base,key1=val1/other/elements,key2=val2"))
564
561
        # TODO: Check full URLs as well as relative references
659
656
        self.assertEqual('%', urlutils.unescape('%25'))
660
657
        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
661
658
 
662
 
        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, u'\xe5')
663
 
        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, '\xe5')
664
 
        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, '%E5')
 
659
        self.assertRaises(InvalidURL, urlutils.unescape, u'\xe5')
 
660
        self.assertRaises(InvalidURL, urlutils.unescape, '\xe5')
 
661
        self.assertRaises(InvalidURL, urlutils.unescape, '%E5')
665
662
 
666
663
    def test_escape_unescape(self):
667
664
        self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
740
737
        self.assertEndsWith(url, '/mytest')
741
738
 
742
739
    def test_non_ascii(self):
 
740
        if win32utils.winver == 'Windows 98':
 
741
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
 
742
 
743
743
        try:
744
744
            os.mkdir(u'dod\xe9')
745
745
        except UnicodeError:
785
785
        self.assertEqual('/foo', result)
786
786
 
787
787
    def test_different_ports(self):
788
 
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
 
788
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
789
789
                              'foo', 'http://bar:80', 'http://bar:81')
790
790
        self.assertEqual(str(e), "URLs differ by more than path:"
791
791
                         " 'http://bar:80' and 'http://bar:81'")
792
792
 
793
793
    def test_different_hosts(self):
794
 
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
 
794
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
795
795
                              'foo', 'http://bar', 'http://baz')
796
796
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
797
797
                         " and 'http://baz'")
798
798
 
799
799
    def test_different_protocol(self):
800
 
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
 
800
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
801
801
                              'foo', 'http://bar', 'ftp://bar')
802
802
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
803
803
                         " and 'ftp://bar'")
830
830
 
831
831
    def test_parse_simple(self):
832
832
        parsed = urlutils.parse_url('http://example.com:80/one')
833
 
        self.assertEqual(('http', None, None, 'example.com', 80, '/one'),
 
833
        self.assertEquals(('http', None, None, 'example.com', 80, '/one'),
834
834
            parsed)
835
835
 
836
836
    def test_ipv6(self):
837
837
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
838
 
        self.assertEqual(('http', None, None, '1:2:3::40', None, '/one'),
 
838
        self.assertEquals(('http', None, None, '1:2:3::40', None, '/one'),
839
839
            parsed)
840
840
 
841
841
    def test_ipv6_port(self):
842
842
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
843
 
        self.assertEqual(('http', None, None, '1:2:3::40', 80, '/one'),
 
843
        self.assertEquals(('http', None, None, '1:2:3::40', 80, '/one'),
844
844
            parsed)
845
845
 
846
846
 
848
848
 
849
849
    def test_parse_simple(self):
850
850
        parsed = urlutils.URL.from_string('http://example.com:80/one')
851
 
        self.assertEqual('http', parsed.scheme)
 
851
        self.assertEquals('http', parsed.scheme)
852
852
        self.assertIs(None, parsed.user)
853
853
        self.assertIs(None, parsed.password)
854
 
        self.assertEqual('example.com', parsed.host)
855
 
        self.assertEqual(80, parsed.port)
856
 
        self.assertEqual('/one', parsed.path)
 
854
        self.assertEquals('example.com', parsed.host)
 
855
        self.assertEquals(80, parsed.port)
 
856
        self.assertEquals('/one', parsed.path)
857
857
 
858
858
    def test_ipv6(self):
859
859
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
860
 
        self.assertEqual('http', parsed.scheme)
 
860
        self.assertEquals('http', parsed.scheme)
861
861
        self.assertIs(None, parsed.port)
862
862
        self.assertIs(None, parsed.user)
863
863
        self.assertIs(None, parsed.password)
864
 
        self.assertEqual('1:2:3::40', parsed.host)
865
 
        self.assertEqual('/one', parsed.path)
 
864
        self.assertEquals('1:2:3::40', parsed.host)
 
865
        self.assertEquals('/one', parsed.path)
866
866
 
867
867
    def test_ipv6_port(self):
868
868
        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)
 
869
        self.assertEquals('http', parsed.scheme)
 
870
        self.assertEquals('1:2:3::40', parsed.host)
871
871
        self.assertIs(None, parsed.user)
872
872
        self.assertIs(None, parsed.password)
873
 
        self.assertEqual(80, parsed.port)
874
 
        self.assertEqual('/one', parsed.path)
 
873
        self.assertEquals(80, parsed.port)
 
874
        self.assertEquals('/one', parsed.path)
875
875
 
876
876
    def test_quoted(self):
877
877
        parsed = urlutils.URL.from_string(
878
878
            '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')
 
879
        self.assertEquals(parsed.quoted_host, 'ex%41mple.com')
 
880
        self.assertEquals(parsed.host, 'exAmple.com')
 
881
        self.assertEquals(parsed.port, 2222)
 
882
        self.assertEquals(parsed.quoted_user, 'ro%62ey')
 
883
        self.assertEquals(parsed.user, 'robey')
 
884
        self.assertEquals(parsed.quoted_password, 'h%40t')
 
885
        self.assertEquals(parsed.password, 'h@t')
 
886
        self.assertEquals(parsed.path, '/path')
887
887
 
888
888
    def test_eq(self):
889
889
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
890
890
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
891
 
        self.assertEqual(parsed1, parsed2)
892
 
        self.assertEqual(parsed1, parsed1)
 
891
        self.assertEquals(parsed1, parsed2)
 
892
        self.assertEquals(parsed1, parsed1)
893
893
        parsed2.path = '/two'
894
 
        self.assertNotEqual(parsed1, parsed2)
 
894
        self.assertNotEquals(parsed1, parsed2)
895
895
 
896
896
    def test_repr(self):
897
897
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
898
 
        self.assertEqual(
 
898
        self.assertEquals(
899
899
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
900
900
            repr(parsed))
901
901
 
902
902
    def test_str(self):
903
903
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
904
 
        self.assertEqual('http://[1:2:3::40]:80/one', str(parsed))
 
904
        self.assertEquals('http://[1:2:3::40]:80/one', str(parsed))
905
905
 
906
906
    def test__combine_paths(self):
907
907
        combine = urlutils.URL._combine_paths
917
917
    def test_clone(self):
918
918
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
919
919
        url1 = url.clone("two")
920
 
        self.assertEqual("/one/two", url1.path)
 
920
        self.assertEquals("/one/two", url1.path)
921
921
        url2 = url.clone("/two")
922
 
        self.assertEqual("/two", url2.path)
 
922
        self.assertEquals("/two", url2.path)
923
923
        url3 = url.clone()
924
924
        self.assertIsNot(url, url3)
925
 
        self.assertEqual(url, url3)
 
925
        self.assertEquals(url, url3)
926
926
 
927
927
 
928
928
class TestFileRelpath(TestCase):
954
954
 
955
955
    def test_same_url_posix(self):
956
956
        self._with_posix_paths()
957
 
        self.assertEqual("",
 
957
        self.assertEquals("",
958
958
            urlutils.file_relpath("file:///a", "file:///a"))
959
 
        self.assertEqual("",
 
959
        self.assertEquals("",
960
960
            urlutils.file_relpath("file:///a", "file:///a/"))
961
 
        self.assertEqual("",
 
961
        self.assertEquals("",
962
962
            urlutils.file_relpath("file:///a/", "file:///a"))
963
963
 
964
964
    def test_same_url_win32(self):
965
965
        self._with_win32_paths()
966
 
        self.assertEqual("",
 
966
        self.assertEquals("",
967
967
            urlutils.file_relpath("file:///A:/", "file:///A:/"))
968
 
        self.assertEqual("",
 
968
        self.assertEquals("",
969
969
            urlutils.file_relpath("file:///A|/", "file:///A:/"))
970
 
        self.assertEqual("",
 
970
        self.assertEquals("",
971
971
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
972
 
        self.assertEqual("",
 
972
        self.assertEquals("",
973
973
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
974
 
        self.assertEqual("",
 
974
        self.assertEquals("",
975
975
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
976
976
 
977
977
    def test_child_posix(self):
978
978
        self._with_posix_paths()
979
 
        self.assertEqual("b",
 
979
        self.assertEquals("b",
980
980
            urlutils.file_relpath("file:///a", "file:///a/b"))
981
 
        self.assertEqual("b",
 
981
        self.assertEquals("b",
982
982
            urlutils.file_relpath("file:///a/", "file:///a/b"))
983
 
        self.assertEqual("b/c",
 
983
        self.assertEquals("b/c",
984
984
            urlutils.file_relpath("file:///a", "file:///a/b/c"))
985
985
 
986
986
    def test_child_win32(self):
987
987
        self._with_win32_paths()
988
 
        self.assertEqual("b",
 
988
        self.assertEquals("b",
989
989
            urlutils.file_relpath("file:///A:/", "file:///A:/b"))
990
 
        self.assertEqual("b",
 
990
        self.assertEquals("b",
991
991
            urlutils.file_relpath("file:///A|/", "file:///A:/b"))
992
 
        self.assertEqual("c",
 
992
        self.assertEquals("c",
993
993
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
994
 
        self.assertEqual("c",
 
994
        self.assertEquals("c",
995
995
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
996
 
        self.assertEqual("c/d",
 
996
        self.assertEquals("c/d",
997
997
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
998
998
 
999
999
    def test_sibling_posix(self):