← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

  • Committer: Martin Pool
  • Date: 2010-02-17 05:12:01 UTC
  • mfrom: (4797.2.16 2.1)
  • mto: This revision was merged to the branch mainline in revision 5037.
  • Revision ID: mbp@sourcefrog.net-20100217051201-1sd9dssoujfdc6c4
merge 2.1 back to trunk

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
156
156
        # Weird stuff
157
157
        # Can't have slashes or colons in the scheme
158
158
        test_one('/path/to/://foo', None)
159
 
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
 
159
        test_one('path:path://foo', None)
160
160
        # Must have more than one character for scheme
161
161
        test_one('C://foo', None)
162
162
        test_one('ab://foo', ('ab', 'foo'))
195
195
            dirname('path/to/foo/', exclude_trailing_slash=False))
196
196
        self.assertEqual('path/..', dirname('path/../foo'))
197
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'))
212
198
 
213
199
    def test_join(self):
214
200
        def test(expected, *args):
224
210
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
225
211
        test('http://foo/baz', 'http://foo', 'bar/../baz')
226
212
        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
213
 
230
214
        # Absolute paths
231
215
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
235
219
        test('http://bar/', 'http://foo', 'http://bar/')
236
220
        test('http://bar/a', 'http://foo', 'http://bar/a')
237
221
        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
222
 
242
223
        # From a base path
243
224
        test('file:///foo', 'file:///', 'foo')
289
270
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
290
271
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
291
272
 
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
 
 
337
273
    def test_function_type(self):
338
274
        if sys.platform == 'win32':
339
 
            self.assertEqual(urlutils._win32_local_path_to_url,
340
 
                urlutils.local_path_to_url)
341
 
            self.assertEqual(urlutils._win32_local_path_from_url,
342
 
                urlutils.local_path_from_url)
 
275
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
 
276
            self.assertEqual(urlutils._win32_local_path_from_url, urlutils.local_path_from_url)
343
277
        else:
344
 
            self.assertEqual(urlutils._posix_local_path_to_url,
345
 
                urlutils.local_path_to_url)
346
 
            self.assertEqual(urlutils._posix_local_path_from_url,
347
 
                urlutils.local_path_from_url)
 
278
            self.assertEqual(urlutils._posix_local_path_to_url, urlutils.local_path_to_url)
 
279
            self.assertEqual(urlutils._posix_local_path_from_url, urlutils.local_path_from_url)
348
280
 
349
281
    def test_posix_local_path_to_url(self):
350
282
        to_url = urlutils._posix_local_path_to_url
351
283
        self.assertEqual('file:///path/to/foo',
352
284
            to_url('/path/to/foo'))
353
285
 
354
 
        self.assertEqual('file:///path/to/foo%2Cbar',
355
 
            to_url('/path/to/foo,bar'))
356
 
 
357
286
        try:
358
287
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
359
288
        except UnicodeError:
366
295
        from_url = urlutils._posix_local_path_from_url
367
296
        self.assertEqual('/path/to/foo',
368
297
            from_url('file:///path/to/foo'))
369
 
        self.assertEqual('/path/to/foo',
370
 
            from_url('file:///path/to/foo,branch=foo'))
371
298
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
372
299
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
373
300
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
395
322
 
396
323
        self.assertEqual('file:///', to_url('/'))
397
324
 
398
 
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
399
 
            to_url('C:/path/to/foo,bar'))
400
325
        try:
401
326
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
402
327
        except UnicodeError:
429
354
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
430
355
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
431
356
        self.assertEqual('/', from_url('file:///'))
432
 
        self.assertEqual('C:/path/to/foo',
433
 
            from_url('file:///C|/path/to/foo,branch=foo'))
434
357
 
435
 
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
436
 
        self.assertRaises(InvalidURL, from_url, 'file:///c')
437
358
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
438
359
        # Not a valid _win32 url, no drive letter
439
360
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
441
362
    def test_win32_unc_path_from_url(self):
442
363
        from_url = urlutils._win32_local_path_from_url
443
364
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
444
 
        self.assertEqual('//HOST/path',
445
 
            from_url('file://HOST/path,branch=foo'))
446
365
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
447
366
        # we want to use only 2 slashes
448
367
        # Firefox understand only 5 slashes in URL, but it's ugly
493
412
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
494
413
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
495
414
 
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
 
 
545
415
    def test_win32_strip_local_trailing_slash(self):
546
416
        strip = urlutils._win32_strip_local_trailing_slash
547
417
        self.assertEqual('file://', strip('file://'))
810
680
 
811
681
class TestParseURL(TestCase):
812
682
 
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)
 
683
    def test_parse_url(self):
 
684
        self.assertEqual(urlutils.parse_url('http://example.com:80/one'),
 
685
            ('http', None, None, 'example.com', 80, '/one'))
 
686
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]/one'),
 
687
                ('http', None, None, '1:2:3::40', None, '/one'))
 
688
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]:80/one'),
 
689
                ('http', None, None, '1:2:3::40', 80, '/one'))