← 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: Alexander Belchenko
  • Date: 2007-02-02 09:14:30 UTC
  • mfrom: (2256 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2259.
  • Revision ID: bialix@ukr.net-20070202091430-vdgouvazded1yfqw
merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for the urlutils wrapper."""
18
18
 
19
19
import os
 
20
import re
20
21
import sys
21
22
 
22
 
from bzrlib import osutils, urlutils, win32utils
23
 
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
 
23
from bzrlib import osutils, urlutils
 
24
import bzrlib
 
25
from bzrlib.errors import InvalidURL, InvalidURLJoin
24
26
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
25
27
 
26
28
 
27
29
class TestUrlToPath(TestCase):
28
 
 
 
30
    
29
31
    def test_basename(self):
30
32
        # bzrlib.urlutils.basename
31
33
        # Test bzrlib.urlutils.split()
80
82
 
81
83
        # Local paths are assumed to *not* be escaped at all
82
84
        try:
83
 
            u'uni/\xb5'.encode(osutils.get_user_encoding())
 
85
            u'uni/\xb5'.encode(bzrlib.user_encoding)
84
86
        except UnicodeError:
85
 
            # locale cannot handle unicode
 
87
            # locale cannot handle unicode 
86
88
            pass
87
89
        else:
88
90
            norm_file('uni/%C2%B5', u'uni/\xb5')
113
115
        eq('http://host/ab/%C2%B5/%C2%B5',
114
116
            normalize_url(u'http://host/ab/%C2%B5/\xb5'))
115
117
 
116
 
        # Unescape characters that don't need to be escaped
117
 
        eq('http://host/~bob%2525-._',
118
 
                normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
119
 
        eq('http://host/~bob%2525-._',
120
 
                normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
121
 
 
122
118
        # Normalize verifies URLs when they are not unicode
123
119
        # (indicating they did not come from the user)
124
120
        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
156
152
        # Weird stuff
157
153
        # Can't have slashes or colons in the scheme
158
154
        test_one('/path/to/://foo', None)
159
 
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
 
155
        test_one('path:path://foo', None)
160
156
        # Must have more than one character for scheme
161
157
        test_one('C://foo', None)
162
158
        test_one('ab://foo', ('ab', 'foo'))
195
191
            dirname('path/to/foo/', exclude_trailing_slash=False))
196
192
        self.assertEqual('path/..', dirname('path/../foo'))
197
193
        self.assertEqual('../path', dirname('../path/foo'))
198
 
    
199
 
    def test_is_url(self):
200
 
        self.assertTrue(urlutils.is_url('http://foo/bar'))
201
 
        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))
202
 
        self.assertTrue(urlutils.is_url('lp:foo/bar'))
203
 
        self.assertTrue(urlutils.is_url('file:///foo/bar'))
204
 
        self.assertFalse(urlutils.is_url(''))
205
 
        self.assertFalse(urlutils.is_url('foo'))
206
 
        self.assertFalse(urlutils.is_url('foo/bar'))
207
 
        self.assertFalse(urlutils.is_url('/foo'))
208
 
        self.assertFalse(urlutils.is_url('/foo/bar'))
209
 
        self.assertFalse(urlutils.is_url('C:/'))
210
 
        self.assertFalse(urlutils.is_url('C:/foo'))
211
 
        self.assertFalse(urlutils.is_url('C:/foo/bar'))
212
194
 
213
195
    def test_join(self):
214
196
        def test(expected, *args):
215
197
            joined = urlutils.join(*args)
216
198
            self.assertEqual(expected, joined)
217
199
 
 
200
        # Test a single element
 
201
        test('foo', 'foo')
 
202
 
218
203
        # Test relative path joining
219
 
        test('foo', 'foo') # relative fragment with nothing is preserved.
220
204
        test('foo/bar', 'foo', 'bar')
221
205
        test('http://foo/bar', 'http://foo', 'bar')
222
206
        test('http://foo/bar', 'http://foo', '.', 'bar')
223
207
        test('http://foo/baz', 'http://foo', 'bar', '../baz')
224
208
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
225
209
        test('http://foo/baz', 'http://foo', 'bar/../baz')
226
 
        test('http://foo/baz', 'http://foo/bar/', '../baz')
227
 
        test('lp:foo/bar', 'lp:foo', 'bar')
228
 
        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')
229
210
 
230
211
        # Absolute paths
231
 
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
232
212
        test('http://bar', 'http://foo', 'http://bar')
233
213
        test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')
234
214
        test('file:///bar', 'foo', 'file:///bar')
235
 
        test('http://bar/', 'http://foo', 'http://bar/')
236
 
        test('http://bar/a', 'http://foo', 'http://bar/a')
237
 
        test('http://bar/a/', 'http://foo', 'http://bar/a/')
238
 
        test('lp:bar', 'http://foo', 'lp:bar')
239
 
        test('lp:bar', 'lp:foo', 'lp:bar')
240
 
        test('file:///stuff', 'lp:foo', 'file:///stuff')
241
215
 
242
216
        # From a base path
243
217
        test('file:///foo', 'file:///', 'foo')
244
218
        test('file:///bar/foo', 'file:///bar/', 'foo')
245
219
        test('http://host/foo', 'http://host/', 'foo')
246
220
        test('http://host/', 'http://host', '')
247
 
 
 
221
        
248
222
        # Invalid joinings
249
223
        # Cannot go above root
250
 
        # Implicitly at root:
251
224
        self.assertRaises(InvalidURLJoin, urlutils.join,
252
225
                'http://foo', '../baz')
253
 
        self.assertRaises(InvalidURLJoin, urlutils.join,
254
 
                'http://foo', '/..')
255
 
        # Joining from a path explicitly under the root.
256
 
        self.assertRaises(InvalidURLJoin, urlutils.join,
257
 
                'http://foo/a', '../../b')
258
 
 
259
 
    def test_joinpath(self):
260
 
        def test(expected, *args):
261
 
            joined = urlutils.joinpath(*args)
262
 
            self.assertEqual(expected, joined)
263
 
 
264
 
        # Test a single element
265
 
        test('foo', 'foo')
266
 
 
267
 
        # Test relative path joining
268
 
        test('foo/bar', 'foo', 'bar')
269
 
        test('foo/bar', 'foo', '.', 'bar')
270
 
        test('foo/baz', 'foo', 'bar', '../baz')
271
 
        test('foo/bar/baz', 'foo', 'bar/baz')
272
 
        test('foo/baz', 'foo', 'bar/../baz')
273
 
 
274
 
        # Test joining to an absolute path
275
 
        test('/foo', '/foo')
276
 
        test('/foo', '/foo', '.')
277
 
        test('/foo/bar', '/foo', 'bar')
278
 
        test('/', '/foo', '..')
279
 
 
280
 
        # Test joining with an absolute path
281
 
        test('/bar', 'foo', '/bar')
282
 
 
283
 
        # Test joining to a path with a trailing slash
284
 
        test('foo/bar', 'foo/', 'bar')
285
 
 
286
 
        # Invalid joinings
287
 
        # Cannot go above root
288
 
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
289
 
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
290
 
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
291
 
 
292
 
    def test_join_segment_parameters_raw(self):
293
 
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
294
 
        self.assertEquals("/somedir/path", 
295
 
            join_segment_parameters_raw("/somedir/path"))
296
 
        self.assertEquals("/somedir/path,rawdata", 
297
 
            join_segment_parameters_raw("/somedir/path", "rawdata"))
298
 
        self.assertRaises(InvalidURLJoin,
299
 
            join_segment_parameters_raw, "/somedir/path",
300
 
                "rawdata1,rawdata2,rawdata3")
301
 
        self.assertEquals("/somedir/path,bla,bar",
302
 
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
303
 
        self.assertEquals("/somedir,exist=some/path,bla,bar",
304
 
            join_segment_parameters_raw("/somedir,exist=some/path",
305
 
                "bla", "bar"))
306
 
        self.assertRaises(TypeError, join_segment_parameters_raw, 
307
 
            "/somepath", 42)
308
 
 
309
 
    def test_join_segment_parameters(self):
310
 
        join_segment_parameters = urlutils.join_segment_parameters
311
 
        self.assertEquals("/somedir/path", 
312
 
            join_segment_parameters("/somedir/path", {}))
313
 
        self.assertEquals("/somedir/path,key1=val1", 
314
 
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
315
 
        self.assertRaises(InvalidURLJoin,
316
 
            join_segment_parameters, "/somedir/path",
317
 
            {"branch": "brr,brr,brr"})
318
 
        self.assertRaises(InvalidURLJoin,
319
 
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
320
 
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
321
 
            join_segment_parameters("/somedir/path", {
322
 
                "key1": "val1", "key2": "val2"}))
323
 
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
324
 
            join_segment_parameters("/somedir/path,key1=val1", {
325
 
                "key2": "val2"}))
326
 
        self.assertEquals("/somedir/path,key1=val2",
327
 
            join_segment_parameters("/somedir/path,key1=val1", {
328
 
                "key1": "val2"}))
329
 
        self.assertEquals("/somedir,exist=some/path,key1=val1",
330
 
            join_segment_parameters("/somedir,exist=some/path",
331
 
                {"key1": "val1"}))
332
 
        self.assertEquals("/,key1=val1,key2=val2",
333
 
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
334
 
        self.assertRaises(TypeError,
335
 
            join_segment_parameters, "/,key1=val1", {"foo": 42})
336
226
 
337
227
    def test_function_type(self):
338
228
        if sys.platform == 'win32':
353
243
            raise TestSkipped("local encoding cannot handle unicode")
354
244
 
355
245
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
356
 
        self.assertFalse(isinstance(result, unicode))
357
246
 
358
247
    def test_posix_local_path_from_url(self):
359
248
        from_url = urlutils._posix_local_path_from_url
363
252
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
364
253
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
365
254
            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
366
 
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
367
 
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
368
255
 
369
256
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
370
 
        self.assertRaises(
371
 
            InvalidURL, from_url,
372
 
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
373
257
 
374
258
    def test_win32_local_path_to_url(self):
375
259
        to_url = urlutils._win32_local_path_to_url
384
268
        self.assertEqual('file:///C:/path/to/f%20oo',
385
269
            to_url('C:/path/to/f oo'))
386
270
 
387
 
        self.assertEqual('file:///', to_url('/'))
388
 
 
389
271
        try:
390
272
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
391
273
        except UnicodeError:
392
274
            raise TestSkipped("local encoding cannot handle unicode")
393
275
 
394
276
        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
395
 
        self.assertFalse(isinstance(result, unicode))
396
277
 
397
278
    def test_win32_unc_path_to_url(self):
398
279
        to_url = urlutils._win32_local_path_to_url
407
288
            raise TestSkipped("local encoding cannot handle unicode")
408
289
 
409
290
        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
410
 
        self.assertFalse(isinstance(result, unicode))
 
291
 
411
292
 
412
293
    def test_win32_local_path_from_url(self):
413
294
        from_url = urlutils._win32_local_path_from_url
417
298
            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
418
299
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
419
300
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
420
 
        self.assertEqual('/', from_url('file:///'))
421
301
 
422
302
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
423
303
        # Not a valid _win32 url, no drive letter
476
356
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
477
357
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
478
358
 
479
 
    def test_split_segment_parameters_raw(self):
480
 
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
481
 
        self.assertEquals(("/some/path", []),
482
 
            split_segment_parameters_raw("/some/path"))
483
 
        self.assertEquals(("/some/path", ["tip"]),
484
 
            split_segment_parameters_raw("/some/path,tip"))
485
 
        self.assertEquals(("/some,dir/path", ["tip"]),
486
 
            split_segment_parameters_raw("/some,dir/path,tip"))
487
 
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
488
 
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
489
 
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
490
 
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
491
 
        self.assertEquals(("/", ["key1=val1"]),
492
 
            split_segment_parameters_raw(",key1=val1"))
493
 
        self.assertEquals(("foo/", ["key1=val1"]),
494
 
            split_segment_parameters_raw("foo/,key1=val1"))
495
 
        self.assertEquals(("foo/base,la=bla/other/elements", []),
496
 
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
497
 
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
498
 
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
499
 
 
500
 
    def test_split_segment_parameters(self):
501
 
        split_segment_parameters = urlutils.split_segment_parameters
502
 
        self.assertEquals(("/some/path", {}),
503
 
            split_segment_parameters("/some/path"))
504
 
        self.assertEquals(("/some/path", {"branch": "tip"}),
505
 
            split_segment_parameters("/some/path,branch=tip"))
506
 
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
507
 
            split_segment_parameters("/some,dir/path,branch=tip"))
508
 
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
509
 
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
510
 
        self.assertEquals(("/somedir/path",
511
 
            {"ref": "heads%2Ftip", "key1": "val1"}),
512
 
            split_segment_parameters(
513
 
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
514
 
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
515
 
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
516
 
        self.assertEquals(("/", {"key1": "val1"}),
517
 
            split_segment_parameters(",key1=val1"))
518
 
        self.assertEquals(("foo/", {"key1": "val1"}),
519
 
            split_segment_parameters("foo/,key1=val1"))
520
 
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
521
 
            split_segment_parameters("foo/base,key1=val1/other/elements"))
522
 
        self.assertEquals(("foo/base,key1=val1/other/elements",
523
 
            {"key2": "val2"}), split_segment_parameters(
524
 
                "foo/base,key1=val1/other/elements,key2=val2"))
525
 
 
526
359
    def test_win32_strip_local_trailing_slash(self):
527
360
        strip = urlutils._win32_strip_local_trailing_slash
528
361
        self.assertEqual('file://', strip('file://'))
610
443
    def test_escape(self):
611
444
        self.assertEqual('%25', urlutils.escape('%'))
612
445
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
613
 
        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
614
 
 
615
 
    def test_escape_tildes(self):
616
 
        self.assertEqual('~foo', urlutils.escape('~foo'))
617
446
 
618
447
    def test_unescape(self):
619
448
        self.assertEqual('%', urlutils.unescape('%25'))
631
460
        def test(expected, base, other):
632
461
            result = urlutils.relative_url(base, other)
633
462
            self.assertEqual(expected, result)
634
 
 
 
463
            
635
464
        test('a', 'http://host/', 'http://host/a')
636
465
        test('http://entirely/different', 'sftp://host/branch',
637
466
                    'http://entirely/different')
646
475
                    'sftp://host/home/jelmer/branch/2b')
647
476
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
648
477
                    'http://host/home/jelmer/branch/feature/%2b')
649
 
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
 
478
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/', 
650
479
                    'http://host/home/jelmer/branch/feature/2b')
651
480
        # relative_url should preserve a trailing slash
652
481
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
664
493
        #test('.', 'http://host/', 'http://host')
665
494
        test('http://host', 'http://host/', 'http://host')
666
495
 
667
 
        # On Windows file:///C:/path/to and file:///D:/other/path
668
 
        # should not use relative url over the non-existent '/' directory.
669
 
        if sys.platform == 'win32':
670
 
            # on the same drive
671
 
            test('../../other/path',
672
 
                'file:///C:/path/to', 'file:///C:/other/path')
673
 
            #~next two tests is failed, i.e. urlutils.relative_url expects
674
 
            #~to see normalized file URLs?
675
 
            #~test('../../other/path',
676
 
            #~    'file:///C:/path/to', 'file:///c:/other/path')
677
 
            #~test('../../other/path',
678
 
            #~    'file:///C:/path/to', 'file:///C|/other/path')
679
 
 
680
 
            # check UNC paths too
681
 
            test('../../other/path',
682
 
                'file://HOST/base/path/to', 'file://HOST/base/other/path')
683
 
            # on different drives
684
 
            test('file:///D:/other/path',
685
 
                'file:///C:/path/to', 'file:///D:/other/path')
686
 
            # TODO: strictly saying in UNC path //HOST/base is full analog
687
 
            # of drive letter for hard disk, and this situation is also
688
 
            # should be exception from rules. [bialix 20071221]
689
 
 
690
496
 
691
497
class TestCwdToURL(TestCaseInTempDir):
692
498
    """Test that local_path_to_url works base on the cwd"""
700
506
        self.assertEndsWith(url, '/mytest')
701
507
 
702
508
    def test_non_ascii(self):
703
 
        if win32utils.winver == 'Windows 98':
704
 
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
705
 
 
706
509
        try:
707
510
            os.mkdir(u'dod\xe9')
708
511
        except UnicodeError:
710
513
 
711
514
        os.chdir(u'dod\xe9')
712
515
 
713
 
        # On Mac OSX this directory is actually:
 
516
        # On Mac OSX this directory is actually: 
714
517
        #   u'/dode\u0301' => '/dode\xcc\x81
715
 
        # but we should normalize it back to
 
518
        # but we should normalize it back to 
716
519
        #   u'/dod\xe9' => '/dod\xc3\xa9'
717
520
        url = urlutils.local_path_to_url('.')
718
521
        self.assertEndsWith(url, '/dod%C3%A9')
719
 
 
720
 
 
721
 
class TestDeriveToLocation(TestCase):
722
 
    """Test that the mapping of FROM_LOCATION to TO_LOCATION works."""
723
 
 
724
 
    def test_to_locations_derived_from_paths(self):
725
 
        derive = urlutils.derive_to_location
726
 
        self.assertEqual("bar", derive("bar"))
727
 
        self.assertEqual("bar", derive("../bar"))
728
 
        self.assertEqual("bar", derive("/foo/bar"))
729
 
        self.assertEqual("bar", derive("c:/foo/bar"))
730
 
        self.assertEqual("bar", derive("c:bar"))
731
 
 
732
 
    def test_to_locations_derived_from_urls(self):
733
 
        derive = urlutils.derive_to_location
734
 
        self.assertEqual("bar", derive("http://foo/bar"))
735
 
        self.assertEqual("bar", derive("bzr+ssh://foo/bar"))
736
 
        self.assertEqual("foo-bar", derive("lp:foo-bar"))
737
 
 
738
 
 
739
 
class TestRebaseURL(TestCase):
740
 
    """Test the behavior of rebase_url."""
741
 
 
742
 
    def test_non_relative(self):
743
 
        result = urlutils.rebase_url('file://foo', 'file://foo',
744
 
                                     'file://foo/bar')
745
 
        self.assertEqual('file://foo', result)
746
 
        result = urlutils.rebase_url('/foo', 'file://foo',
747
 
                                     'file://foo/bar')
748
 
        self.assertEqual('/foo', result)
749
 
 
750
 
    def test_different_ports(self):
751
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
752
 
                              'foo', 'http://bar:80', 'http://bar:81')
753
 
        self.assertEqual(str(e), "URLs differ by more than path:"
754
 
                         " 'http://bar:80' and 'http://bar:81'")
755
 
 
756
 
    def test_different_hosts(self):
757
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
758
 
                              'foo', 'http://bar', 'http://baz')
759
 
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
760
 
                         " and 'http://baz'")
761
 
 
762
 
    def test_different_protocol(self):
763
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
764
 
                              'foo', 'http://bar', 'ftp://bar')
765
 
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
766
 
                         " and 'ftp://bar'")
767
 
 
768
 
    def test_rebase_success(self):
769
 
        self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',
770
 
                         'http://baz/qux'))
771
 
        self.assertEqual('qux/bar', urlutils.rebase_url('bar',
772
 
                         'http://baz/qux', 'http://baz/'))
773
 
        self.assertEqual('.', urlutils.rebase_url('foo',
774
 
                         'http://bar/', 'http://bar/foo/'))
775
 
        self.assertEqual('qux/bar', urlutils.rebase_url('../bar',
776
 
                         'http://baz/qux/foo', 'http://baz/'))
777
 
 
778
 
    def test_determine_relative_path(self):
779
 
        self.assertEqual('../../baz/bar',
780
 
                         urlutils.determine_relative_path(
781
 
                         '/qux/quxx', '/baz/bar'))
782
 
        self.assertEqual('..',
783
 
                         urlutils.determine_relative_path(
784
 
                         '/bar/baz', '/bar'))
785
 
        self.assertEqual('baz',
786
 
                         urlutils.determine_relative_path(
787
 
                         '/bar', '/bar/baz'))
788
 
        self.assertEqual('.', urlutils.determine_relative_path(
789
 
                         '/bar', '/bar'))
790
 
 
791
 
 
792
 
class TestParseURL(TestCase):
793
 
 
794
 
    def test_parse_url(self):
795
 
        self.assertEqual(urlutils.parse_url('http://example.com:80/one'),
796
 
            ('http', None, None, 'example.com', 80, '/one'))
797
 
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]/one'),
798
 
                ('http', None, None, '1:2:3::40', None, '/one'))
799
 
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]:80/one'),
800
 
                ('http', None, None, '1:2:3::40', 80, '/one'))