← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

Merge bzr.dev and tree-file-ids-as-tuples.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2005 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
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the urlutils wrapper."""
18
18
 
19
19
import os
20
 
import re
21
20
import sys
22
21
 
23
22
from bzrlib import osutils, urlutils, win32utils
24
 
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
 
23
from bzrlib.errors import (
 
24
    InvalidURL,
 
25
    InvalidURLJoin,
 
26
    InvalidRebaseURLs,
 
27
    PathNotChild,
 
28
    )
25
29
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
26
30
 
27
31
 
28
32
class TestUrlToPath(TestCase):
29
 
    
 
33
 
30
34
    def test_basename(self):
31
35
        # bzrlib.urlutils.basename
32
36
        # Test bzrlib.urlutils.split()
83
87
        try:
84
88
            u'uni/\xb5'.encode(osutils.get_user_encoding())
85
89
        except UnicodeError:
86
 
            # locale cannot handle unicode 
 
90
            # locale cannot handle unicode
87
91
            pass
88
92
        else:
89
93
            norm_file('uni/%C2%B5', u'uni/\xb5')
157
161
        # Weird stuff
158
162
        # Can't have slashes or colons in the scheme
159
163
        test_one('/path/to/://foo', None)
160
 
        test_one('path:path://foo', None)
 
164
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
161
165
        # Must have more than one character for scheme
162
166
        test_one('C://foo', None)
163
167
        test_one('ab://foo', ('ab', 'foo'))
196
200
            dirname('path/to/foo/', exclude_trailing_slash=False))
197
201
        self.assertEqual('path/..', dirname('path/../foo'))
198
202
        self.assertEqual('../path', dirname('../path/foo'))
 
203
    
 
204
    def test_is_url(self):
 
205
        self.assertTrue(urlutils.is_url('http://foo/bar'))
 
206
        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))
 
207
        self.assertTrue(urlutils.is_url('lp:foo/bar'))
 
208
        self.assertTrue(urlutils.is_url('file:///foo/bar'))
 
209
        self.assertFalse(urlutils.is_url(''))
 
210
        self.assertFalse(urlutils.is_url('foo'))
 
211
        self.assertFalse(urlutils.is_url('foo/bar'))
 
212
        self.assertFalse(urlutils.is_url('/foo'))
 
213
        self.assertFalse(urlutils.is_url('/foo/bar'))
 
214
        self.assertFalse(urlutils.is_url('C:/'))
 
215
        self.assertFalse(urlutils.is_url('C:/foo'))
 
216
        self.assertFalse(urlutils.is_url('C:/foo/bar'))
199
217
 
200
218
    def test_join(self):
201
219
        def test(expected, *args):
211
229
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
212
230
        test('http://foo/baz', 'http://foo', 'bar/../baz')
213
231
        test('http://foo/baz', 'http://foo/bar/', '../baz')
 
232
        test('lp:foo/bar', 'lp:foo', 'bar')
 
233
        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')
214
234
 
215
235
        # Absolute paths
216
236
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
220
240
        test('http://bar/', 'http://foo', 'http://bar/')
221
241
        test('http://bar/a', 'http://foo', 'http://bar/a')
222
242
        test('http://bar/a/', 'http://foo', 'http://bar/a/')
 
243
        test('lp:bar', 'http://foo', 'lp:bar')
 
244
        test('lp:bar', 'lp:foo', 'lp:bar')
 
245
        test('file:///stuff', 'lp:foo', 'file:///stuff')
223
246
 
224
247
        # From a base path
225
248
        test('file:///foo', 'file:///', 'foo')
226
249
        test('file:///bar/foo', 'file:///bar/', 'foo')
227
250
        test('http://host/foo', 'http://host/', 'foo')
228
251
        test('http://host/', 'http://host', '')
229
 
        
 
252
 
230
253
        # Invalid joinings
231
254
        # Cannot go above root
232
255
        # Implicitly at root:
264
287
 
265
288
        # Test joining to a path with a trailing slash
266
289
        test('foo/bar', 'foo/', 'bar')
267
 
        
 
290
 
268
291
        # Invalid joinings
269
292
        # Cannot go above root
270
293
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
271
294
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
272
295
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
273
296
 
 
297
    def test_join_segment_parameters_raw(self):
 
298
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
 
299
        self.assertEquals("/somedir/path", 
 
300
            join_segment_parameters_raw("/somedir/path"))
 
301
        self.assertEquals("/somedir/path,rawdata", 
 
302
            join_segment_parameters_raw("/somedir/path", "rawdata"))
 
303
        self.assertRaises(InvalidURLJoin,
 
304
            join_segment_parameters_raw, "/somedir/path",
 
305
                "rawdata1,rawdata2,rawdata3")
 
306
        self.assertEquals("/somedir/path,bla,bar",
 
307
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
 
308
        self.assertEquals("/somedir,exist=some/path,bla,bar",
 
309
            join_segment_parameters_raw("/somedir,exist=some/path",
 
310
                "bla", "bar"))
 
311
        self.assertRaises(TypeError, join_segment_parameters_raw, 
 
312
            "/somepath", 42)
 
313
 
 
314
    def test_join_segment_parameters(self):
 
315
        join_segment_parameters = urlutils.join_segment_parameters
 
316
        self.assertEquals("/somedir/path", 
 
317
            join_segment_parameters("/somedir/path", {}))
 
318
        self.assertEquals("/somedir/path,key1=val1", 
 
319
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
 
320
        self.assertRaises(InvalidURLJoin,
 
321
            join_segment_parameters, "/somedir/path",
 
322
            {"branch": "brr,brr,brr"})
 
323
        self.assertRaises(InvalidURLJoin,
 
324
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
 
325
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
326
            join_segment_parameters("/somedir/path", {
 
327
                "key1": "val1", "key2": "val2"}))
 
328
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
329
            join_segment_parameters("/somedir/path,key1=val1", {
 
330
                "key2": "val2"}))
 
331
        self.assertEquals("/somedir/path,key1=val2",
 
332
            join_segment_parameters("/somedir/path,key1=val1", {
 
333
                "key1": "val2"}))
 
334
        self.assertEquals("/somedir,exist=some/path,key1=val1",
 
335
            join_segment_parameters("/somedir,exist=some/path",
 
336
                {"key1": "val1"}))
 
337
        self.assertEquals("/,key1=val1,key2=val2",
 
338
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
 
339
        self.assertRaises(TypeError,
 
340
            join_segment_parameters, "/,key1=val1", {"foo": 42})
 
341
 
274
342
    def test_function_type(self):
275
343
        if sys.platform == 'win32':
276
 
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
277
 
            self.assertEqual(urlutils._win32_local_path_from_url, urlutils.local_path_from_url)
 
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)
278
348
        else:
279
 
            self.assertEqual(urlutils._posix_local_path_to_url, urlutils.local_path_to_url)
280
 
            self.assertEqual(urlutils._posix_local_path_from_url, urlutils.local_path_from_url)
 
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)
281
353
 
282
354
    def test_posix_local_path_to_url(self):
283
355
        to_url = urlutils._posix_local_path_to_url
284
356
        self.assertEqual('file:///path/to/foo',
285
357
            to_url('/path/to/foo'))
286
358
 
 
359
        self.assertEqual('file:///path/to/foo%2Cbar',
 
360
            to_url('/path/to/foo,bar'))
 
361
 
287
362
        try:
288
363
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
289
364
        except UnicodeError:
296
371
        from_url = urlutils._posix_local_path_from_url
297
372
        self.assertEqual('/path/to/foo',
298
373
            from_url('file:///path/to/foo'))
 
374
        self.assertEqual('/path/to/foo',
 
375
            from_url('file:///path/to/foo,branch=foo'))
299
376
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
300
377
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
301
378
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
302
379
            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
 
380
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
381
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
303
382
 
304
383
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
 
384
        self.assertRaises(
 
385
            InvalidURL, from_url,
 
386
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
305
387
 
306
388
    def test_win32_local_path_to_url(self):
307
389
        to_url = urlutils._win32_local_path_to_url
315
397
        #     to_url('C:/path/to/foo '))
316
398
        self.assertEqual('file:///C:/path/to/f%20oo',
317
399
            to_url('C:/path/to/f oo'))
318
 
        
 
400
 
319
401
        self.assertEqual('file:///', to_url('/'))
320
402
 
 
403
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
 
404
            to_url('C:/path/to/foo,bar'))
321
405
        try:
322
406
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
323
407
        except UnicodeError:
350
434
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
351
435
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
352
436
        self.assertEqual('/', from_url('file:///'))
 
437
        self.assertEqual('C:/path/to/foo',
 
438
            from_url('file:///C|/path/to/foo,branch=foo'))
353
439
 
 
440
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
 
441
        self.assertRaises(InvalidURL, from_url, 'file:///c')
354
442
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
355
443
        # Not a valid _win32 url, no drive letter
356
444
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
358
446
    def test_win32_unc_path_from_url(self):
359
447
        from_url = urlutils._win32_local_path_from_url
360
448
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
 
449
        self.assertEqual('//HOST/path',
 
450
            from_url('file://HOST/path,branch=foo'))
361
451
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
362
452
        # we want to use only 2 slashes
363
453
        # Firefox understand only 5 slashes in URL, but it's ugly
372
462
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
373
463
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
374
464
        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')
375
471
 
376
472
    def test_split(self):
377
473
        # Test bzrlib.urlutils.split()
408
504
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
409
505
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
410
506
 
 
507
    def test_split_segment_parameters_raw(self):
 
508
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
 
509
        # Check relative references with absolute paths
 
510
        self.assertEquals(("/some/path", []),
 
511
            split_segment_parameters_raw("/some/path"))
 
512
        self.assertEquals(("/some/path", ["tip"]),
 
513
            split_segment_parameters_raw("/some/path,tip"))
 
514
        self.assertEquals(("/some,dir/path", ["tip"]),
 
515
            split_segment_parameters_raw("/some,dir/path,tip"))
 
516
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
 
517
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
 
518
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
 
519
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
 
520
        # Check relative references with relative paths
 
521
        self.assertEquals(("", ["key1=val1"]),
 
522
            split_segment_parameters_raw(",key1=val1"))
 
523
        self.assertEquals(("foo/", ["key1=val1"]),
 
524
            split_segment_parameters_raw("foo/,key1=val1"))
 
525
        self.assertEquals(("foo", ["key1=val1"]),
 
526
            split_segment_parameters_raw("foo,key1=val1"))
 
527
        self.assertEquals(("foo/base,la=bla/other/elements", []),
 
528
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
 
529
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
 
530
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
 
531
        # TODO: Check full URLs as well as relative references
 
532
 
 
533
    def test_split_segment_parameters(self):
 
534
        split_segment_parameters = urlutils.split_segment_parameters
 
535
        # Check relative references with absolute paths
 
536
        self.assertEquals(("/some/path", {}),
 
537
            split_segment_parameters("/some/path"))
 
538
        self.assertEquals(("/some/path", {"branch": "tip"}),
 
539
            split_segment_parameters("/some/path,branch=tip"))
 
540
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
 
541
            split_segment_parameters("/some,dir/path,branch=tip"))
 
542
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
 
543
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
 
544
        self.assertEquals(("/somedir/path",
 
545
            {"ref": "heads%2Ftip", "key1": "val1"}),
 
546
            split_segment_parameters(
 
547
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
 
548
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
 
549
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
 
550
        # Check relative references with relative paths
 
551
        self.assertEquals(("", {"key1": "val1"}),
 
552
            split_segment_parameters(",key1=val1"))
 
553
        self.assertEquals(("foo/", {"key1": "val1"}),
 
554
            split_segment_parameters("foo/,key1=val1"))
 
555
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
 
556
            split_segment_parameters("foo/base,key1=val1/other/elements"))
 
557
        self.assertEquals(("foo/base,key1=val1/other/elements",
 
558
            {"key2": "val2"}), split_segment_parameters(
 
559
                "foo/base,key1=val1/other/elements,key2=val2"))
 
560
        # TODO: Check full URLs as well as relative references
 
561
 
411
562
    def test_win32_strip_local_trailing_slash(self):
412
563
        strip = urlutils._win32_strip_local_trailing_slash
413
564
        self.assertEqual('file://', strip('file://'))
497
648
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
498
649
        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
499
650
 
 
651
    def test_escape_tildes(self):
 
652
        self.assertEqual('~foo', urlutils.escape('~foo'))
 
653
 
500
654
    def test_unescape(self):
501
655
        self.assertEqual('%', urlutils.unescape('%25'))
502
656
        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
513
667
        def test(expected, base, other):
514
668
            result = urlutils.relative_url(base, other)
515
669
            self.assertEqual(expected, result)
516
 
            
 
670
 
517
671
        test('a', 'http://host/', 'http://host/a')
518
672
        test('http://entirely/different', 'sftp://host/branch',
519
673
                    'http://entirely/different')
528
682
                    'sftp://host/home/jelmer/branch/2b')
529
683
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
530
684
                    'http://host/home/jelmer/branch/feature/%2b')
531
 
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/', 
 
685
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
532
686
                    'http://host/home/jelmer/branch/feature/2b')
533
687
        # relative_url should preserve a trailing slash
534
688
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
571
725
 
572
726
 
573
727
class TestCwdToURL(TestCaseInTempDir):
574
 
    """Test that local_path_to_url works base on the cwd"""
 
728
    """Test that local_path_to_url works based on the cwd"""
575
729
 
576
730
    def test_dot(self):
577
731
        # This test will fail if getcwd is not ascii
592
746
 
593
747
        os.chdir(u'dod\xe9')
594
748
 
595
 
        # On Mac OSX this directory is actually: 
 
749
        # On Mac OSX this directory is actually:
596
750
        #   u'/dode\u0301' => '/dode\xcc\x81
597
 
        # but we should normalize it back to 
 
751
        # but we should normalize it back to
598
752
        #   u'/dod\xe9' => '/dod\xc3\xa9'
599
753
        url = urlutils.local_path_to_url('.')
600
754
        self.assertEndsWith(url, '/dod%C3%A9')
669
823
                         '/bar', '/bar/baz'))
670
824
        self.assertEqual('.', urlutils.determine_relative_path(
671
825
                         '/bar', '/bar'))
 
826
 
 
827
 
 
828
class TestParseURL(TestCase):
 
829
 
 
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'))