← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

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-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
26
25
 
27
26
 
28
27
class TestUrlToPath(TestCase):
29
 
    
 
28
 
30
29
    def test_basename(self):
31
30
        # bzrlib.urlutils.basename
32
31
        # Test bzrlib.urlutils.split()
83
82
        try:
84
83
            u'uni/\xb5'.encode(osutils.get_user_encoding())
85
84
        except UnicodeError:
86
 
            # locale cannot handle unicode 
 
85
            # locale cannot handle unicode
87
86
            pass
88
87
        else:
89
88
            norm_file('uni/%C2%B5', u'uni/\xb5')
157
156
        # Weird stuff
158
157
        # Can't have slashes or colons in the scheme
159
158
        test_one('/path/to/://foo', None)
160
 
        test_one('path:path://foo', None)
 
159
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
161
160
        # Must have more than one character for scheme
162
161
        test_one('C://foo', None)
163
162
        test_one('ab://foo', ('ab', 'foo'))
196
195
            dirname('path/to/foo/', exclude_trailing_slash=False))
197
196
        self.assertEqual('path/..', dirname('path/../foo'))
198
197
        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'))
199
212
 
200
213
    def test_join(self):
201
214
        def test(expected, *args):
211
224
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
212
225
        test('http://foo/baz', 'http://foo', 'bar/../baz')
213
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')
214
229
 
215
230
        # Absolute paths
216
231
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
220
235
        test('http://bar/', 'http://foo', 'http://bar/')
221
236
        test('http://bar/a', 'http://foo', 'http://bar/a')
222
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')
223
241
 
224
242
        # From a base path
225
243
        test('file:///foo', 'file:///', 'foo')
226
244
        test('file:///bar/foo', 'file:///bar/', 'foo')
227
245
        test('http://host/foo', 'http://host/', 'foo')
228
246
        test('http://host/', 'http://host', '')
229
 
        
 
247
 
230
248
        # Invalid joinings
231
249
        # Cannot go above root
232
250
        # Implicitly at root:
264
282
 
265
283
        # Test joining to a path with a trailing slash
266
284
        test('foo/bar', 'foo/', 'bar')
267
 
        
 
285
 
268
286
        # Invalid joinings
269
287
        # Cannot go above root
270
288
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
271
289
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
272
290
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
273
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
 
274
337
    def test_function_type(self):
275
338
        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)
 
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)
278
343
        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)
 
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)
281
348
 
282
349
    def test_posix_local_path_to_url(self):
283
350
        to_url = urlutils._posix_local_path_to_url
284
351
        self.assertEqual('file:///path/to/foo',
285
352
            to_url('/path/to/foo'))
286
353
 
 
354
        self.assertEqual('file:///path/to/foo%2Cbar',
 
355
            to_url('/path/to/foo,bar'))
 
356
 
287
357
        try:
288
358
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
289
359
        except UnicodeError:
296
366
        from_url = urlutils._posix_local_path_from_url
297
367
        self.assertEqual('/path/to/foo',
298
368
            from_url('file:///path/to/foo'))
 
369
        self.assertEqual('/path/to/foo',
 
370
            from_url('file:///path/to/foo,branch=foo'))
299
371
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
300
372
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
301
373
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
302
374
            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
 
375
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
376
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
303
377
 
304
378
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
 
379
        self.assertRaises(
 
380
            InvalidURL, from_url,
 
381
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
305
382
 
306
383
    def test_win32_local_path_to_url(self):
307
384
        to_url = urlutils._win32_local_path_to_url
315
392
        #     to_url('C:/path/to/foo '))
316
393
        self.assertEqual('file:///C:/path/to/f%20oo',
317
394
            to_url('C:/path/to/f oo'))
318
 
        
 
395
 
319
396
        self.assertEqual('file:///', to_url('/'))
320
397
 
 
398
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
 
399
            to_url('C:/path/to/foo,bar'))
321
400
        try:
322
401
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
323
402
        except UnicodeError:
350
429
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
351
430
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
352
431
        self.assertEqual('/', from_url('file:///'))
 
432
        self.assertEqual('C:/path/to/foo',
 
433
            from_url('file:///C|/path/to/foo,branch=foo'))
353
434
 
 
435
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
 
436
        self.assertRaises(InvalidURL, from_url, 'file:///c')
354
437
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
355
438
        # Not a valid _win32 url, no drive letter
356
439
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
358
441
    def test_win32_unc_path_from_url(self):
359
442
        from_url = urlutils._win32_local_path_from_url
360
443
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
 
444
        self.assertEqual('//HOST/path',
 
445
            from_url('file://HOST/path,branch=foo'))
361
446
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
362
447
        # we want to use only 2 slashes
363
448
        # Firefox understand only 5 slashes in URL, but it's ugly
408
493
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
409
494
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
410
495
 
 
496
    def test_split_segment_parameters_raw(self):
 
497
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
 
498
        self.assertEquals(("/some/path", []),
 
499
            split_segment_parameters_raw("/some/path"))
 
500
        self.assertEquals(("/some/path", ["tip"]),
 
501
            split_segment_parameters_raw("/some/path,tip"))
 
502
        self.assertEquals(("/some,dir/path", ["tip"]),
 
503
            split_segment_parameters_raw("/some,dir/path,tip"))
 
504
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
 
505
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
 
506
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
 
507
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
 
508
        self.assertEquals(("/", ["key1=val1"]),
 
509
            split_segment_parameters_raw(",key1=val1"))
 
510
        self.assertEquals(("foo/", ["key1=val1"]),
 
511
            split_segment_parameters_raw("foo/,key1=val1"))
 
512
        self.assertEquals(("/foo", ["key1=val1"]),
 
513
            split_segment_parameters_raw("foo,key1=val1"))
 
514
        self.assertEquals(("foo/base,la=bla/other/elements", []),
 
515
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
 
516
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
 
517
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
 
518
 
 
519
    def test_split_segment_parameters(self):
 
520
        split_segment_parameters = urlutils.split_segment_parameters
 
521
        self.assertEquals(("/some/path", {}),
 
522
            split_segment_parameters("/some/path"))
 
523
        self.assertEquals(("/some/path", {"branch": "tip"}),
 
524
            split_segment_parameters("/some/path,branch=tip"))
 
525
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
 
526
            split_segment_parameters("/some,dir/path,branch=tip"))
 
527
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
 
528
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
 
529
        self.assertEquals(("/somedir/path",
 
530
            {"ref": "heads%2Ftip", "key1": "val1"}),
 
531
            split_segment_parameters(
 
532
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
 
533
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
 
534
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
 
535
        self.assertEquals(("/", {"key1": "val1"}),
 
536
            split_segment_parameters(",key1=val1"))
 
537
        self.assertEquals(("foo/", {"key1": "val1"}),
 
538
            split_segment_parameters("foo/,key1=val1"))
 
539
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
 
540
            split_segment_parameters("foo/base,key1=val1/other/elements"))
 
541
        self.assertEquals(("foo/base,key1=val1/other/elements",
 
542
            {"key2": "val2"}), split_segment_parameters(
 
543
                "foo/base,key1=val1/other/elements,key2=val2"))
 
544
 
411
545
    def test_win32_strip_local_trailing_slash(self):
412
546
        strip = urlutils._win32_strip_local_trailing_slash
413
547
        self.assertEqual('file://', strip('file://'))
497
631
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
498
632
        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
499
633
 
 
634
    def test_escape_tildes(self):
 
635
        self.assertEqual('~foo', urlutils.escape('~foo'))
 
636
 
500
637
    def test_unescape(self):
501
638
        self.assertEqual('%', urlutils.unescape('%25'))
502
639
        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
513
650
        def test(expected, base, other):
514
651
            result = urlutils.relative_url(base, other)
515
652
            self.assertEqual(expected, result)
516
 
            
 
653
 
517
654
        test('a', 'http://host/', 'http://host/a')
518
655
        test('http://entirely/different', 'sftp://host/branch',
519
656
                    'http://entirely/different')
528
665
                    'sftp://host/home/jelmer/branch/2b')
529
666
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
530
667
                    'http://host/home/jelmer/branch/feature/%2b')
531
 
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/', 
 
668
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
532
669
                    'http://host/home/jelmer/branch/feature/2b')
533
670
        # relative_url should preserve a trailing slash
534
671
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
592
729
 
593
730
        os.chdir(u'dod\xe9')
594
731
 
595
 
        # On Mac OSX this directory is actually: 
 
732
        # On Mac OSX this directory is actually:
596
733
        #   u'/dode\u0301' => '/dode\xcc\x81
597
 
        # but we should normalize it back to 
 
734
        # but we should normalize it back to
598
735
        #   u'/dod\xe9' => '/dod\xc3\xa9'
599
736
        url = urlutils.local_path_to_url('.')
600
737
        self.assertEndsWith(url, '/dod%C3%A9')
669
806
                         '/bar', '/bar/baz'))
670
807
        self.assertEqual('.', urlutils.determine_relative_path(
671
808
                         '/bar', '/bar'))
 
809
 
 
810
 
 
811
class TestParseURL(TestCase):
 
812
 
 
813
    def test_parse_simple(self):
 
814
        parsed = urlutils.parse_url('http://example.com:80/one')
 
815
        self.assertEquals(('http', None, None, 'example.com', 80, '/one'),
 
816
            parsed)
 
817
 
 
818
    def test_ipv6(self):
 
819
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
 
820
        self.assertEquals(('http', None, None, '1:2:3::40', None, '/one'),
 
821
            parsed)
 
822
 
 
823
    def test_ipv6_port(self):
 
824
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
 
825
        self.assertEquals(('http', None, None, '1:2:3::40', 80, '/one'),
 
826
            parsed)
 
827
 
 
828
 
 
829
class TestURL(TestCase):
 
830
 
 
831
    def test_parse_simple(self):
 
832
        parsed = urlutils.URL.from_string('http://example.com:80/one')
 
833
        self.assertEquals('http', parsed.scheme)
 
834
        self.assertIs(None, parsed.user)
 
835
        self.assertIs(None, parsed.password)
 
836
        self.assertEquals('example.com', parsed.host)
 
837
        self.assertEquals(80, parsed.port)
 
838
        self.assertEquals('/one', parsed.path)
 
839
 
 
840
    def test_ipv6(self):
 
841
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
 
842
        self.assertEquals('http', parsed.scheme)
 
843
        self.assertIs(None, parsed.port)
 
844
        self.assertIs(None, parsed.user)
 
845
        self.assertIs(None, parsed.password)
 
846
        self.assertEquals('1:2:3::40', parsed.host)
 
847
        self.assertEquals('/one', parsed.path)
 
848
 
 
849
    def test_ipv6_port(self):
 
850
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
851
        self.assertEquals('http', parsed.scheme)
 
852
        self.assertEquals('1:2:3::40', parsed.host)
 
853
        self.assertIs(None, parsed.user)
 
854
        self.assertIs(None, parsed.password)
 
855
        self.assertEquals(80, parsed.port)
 
856
        self.assertEquals('/one', parsed.path)
 
857
 
 
858
    def test_quoted(self):
 
859
        parsed = urlutils.URL.from_string(
 
860
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
 
861
        self.assertEquals(parsed.quoted_host, 'ex%41mple.com')
 
862
        self.assertEquals(parsed.host, 'exAmple.com')
 
863
        self.assertEquals(parsed.port, 2222)
 
864
        self.assertEquals(parsed.quoted_user, 'ro%62ey')
 
865
        self.assertEquals(parsed.user, 'robey')
 
866
        self.assertEquals(parsed.quoted_password, 'h%40t')
 
867
        self.assertEquals(parsed.password, 'h@t')
 
868
        self.assertEquals(parsed.path, '/path')
 
869
 
 
870
    def test_eq(self):
 
871
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
872
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
873
        self.assertEquals(parsed1, parsed2)
 
874
        self.assertEquals(parsed1, parsed1)
 
875
        parsed2.path = '/two'
 
876
        self.assertNotEquals(parsed1, parsed2)
 
877
 
 
878
    def test_repr(self):
 
879
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
880
        self.assertEquals(
 
881
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
 
882
            repr(parsed))
 
883
 
 
884
    def test_str(self):
 
885
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
886
        self.assertEquals('http://[1:2:3::40]:80/one', str(parsed))
 
887
 
 
888
    def test__combine_paths(self):
 
889
        combine = urlutils.URL._combine_paths
 
890
        self.assertEqual('/home/sarah/project/foo',
 
891
                         combine('/home/sarah', 'project/foo'))
 
892
        self.assertEqual('/etc',
 
893
                         combine('/home/sarah', '../../etc'))
 
894
        self.assertEqual('/etc',
 
895
                         combine('/home/sarah', '../../../etc'))
 
896
        self.assertEqual('/etc',
 
897
                         combine('/home/sarah', '/etc'))
 
898
 
 
899
    def test_clone(self):
 
900
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
901
        url1 = url.clone("two")
 
902
        self.assertEquals("/one/two", url1.path)
 
903
        url2 = url.clone("/two")
 
904
        self.assertEquals("/two", url2.path)
 
905
        url3 = url.clone()
 
906
        self.assertIsNot(url, url3)
 
907
        self.assertEquals(url, url3)