← 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: John Arbash Meinel
  • Date: 2011-10-03 14:15:44 UTC
  • mto: This revision was merged to the branch mainline in revision 6186.
  • Revision ID: john@arbash-meinel.com-20111003141544-2upoh3swgxqerfv7
Separate the comments, for vila.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
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('path:path://foo', None)
 
159
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
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'))
198
212
 
199
213
    def test_join(self):
200
214
        def test(expected, *args):
210
224
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
211
225
        test('http://foo/baz', 'http://foo', 'bar/../baz')
212
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')
213
229
 
214
230
        # Absolute paths
215
231
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
219
235
        test('http://bar/', 'http://foo', 'http://bar/')
220
236
        test('http://bar/a', 'http://foo', 'http://bar/a')
221
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')
222
241
 
223
242
        # From a base path
224
243
        test('file:///foo', 'file:///', 'foo')
270
289
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
271
290
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
272
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
 
273
337
    def test_function_type(self):
274
338
        if sys.platform == 'win32':
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)
 
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)
277
343
        else:
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)
 
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)
280
348
 
281
349
    def test_posix_local_path_to_url(self):
282
350
        to_url = urlutils._posix_local_path_to_url
283
351
        self.assertEqual('file:///path/to/foo',
284
352
            to_url('/path/to/foo'))
285
353
 
 
354
        self.assertEqual('file:///path/to/foo%2Cbar',
 
355
            to_url('/path/to/foo,bar'))
 
356
 
286
357
        try:
287
358
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
288
359
        except UnicodeError:
295
366
        from_url = urlutils._posix_local_path_from_url
296
367
        self.assertEqual('/path/to/foo',
297
368
            from_url('file:///path/to/foo'))
 
369
        self.assertEqual('/path/to/foo',
 
370
            from_url('file:///path/to/foo,branch=foo'))
298
371
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
299
372
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
300
373
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
322
395
 
323
396
        self.assertEqual('file:///', to_url('/'))
324
397
 
 
398
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
 
399
            to_url('C:/path/to/foo,bar'))
325
400
        try:
326
401
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
327
402
        except UnicodeError:
354
429
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
355
430
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
356
431
        self.assertEqual('/', from_url('file:///'))
 
432
        self.assertEqual('C:/path/to/foo',
 
433
            from_url('file:///C|/path/to/foo,branch=foo'))
357
434
 
 
435
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
 
436
        self.assertRaises(InvalidURL, from_url, 'file:///c')
358
437
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
359
438
        # Not a valid _win32 url, no drive letter
360
439
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
362
441
    def test_win32_unc_path_from_url(self):
363
442
        from_url = urlutils._win32_local_path_from_url
364
443
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
 
444
        self.assertEqual('//HOST/path',
 
445
            from_url('file://HOST/path,branch=foo'))
365
446
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
366
447
        # we want to use only 2 slashes
367
448
        # Firefox understand only 5 slashes in URL, but it's ugly
376
457
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
377
458
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
378
459
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
 
460
        # Root drives without slash treated as invalid, see bug #841322
 
461
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
 
462
        self.assertRaises(InvalidURL, extract, 'file://', '/C:')
 
463
        # Invalid without drive separator or following forward slash
 
464
        self.assertRaises(InvalidURL, extract, 'file://', '/C')
 
465
        self.assertRaises(InvalidURL, extract, 'file://', '/C:ool')
379
466
 
380
467
    def test_split(self):
381
468
        # Test bzrlib.urlutils.split()
412
499
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
413
500
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
414
501
 
 
502
    def test_split_segment_parameters_raw(self):
 
503
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
 
504
        self.assertEquals(("/some/path", []),
 
505
            split_segment_parameters_raw("/some/path"))
 
506
        self.assertEquals(("/some/path", ["tip"]),
 
507
            split_segment_parameters_raw("/some/path,tip"))
 
508
        self.assertEquals(("/some,dir/path", ["tip"]),
 
509
            split_segment_parameters_raw("/some,dir/path,tip"))
 
510
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
 
511
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
 
512
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
 
513
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
 
514
        self.assertEquals(("/", ["key1=val1"]),
 
515
            split_segment_parameters_raw(",key1=val1"))
 
516
        self.assertEquals(("foo/", ["key1=val1"]),
 
517
            split_segment_parameters_raw("foo/,key1=val1"))
 
518
        self.assertEquals(("/foo", ["key1=val1"]),
 
519
            split_segment_parameters_raw("foo,key1=val1"))
 
520
        self.assertEquals(("foo/base,la=bla/other/elements", []),
 
521
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
 
522
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
 
523
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
 
524
 
 
525
    def test_split_segment_parameters(self):
 
526
        split_segment_parameters = urlutils.split_segment_parameters
 
527
        self.assertEquals(("/some/path", {}),
 
528
            split_segment_parameters("/some/path"))
 
529
        self.assertEquals(("/some/path", {"branch": "tip"}),
 
530
            split_segment_parameters("/some/path,branch=tip"))
 
531
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
 
532
            split_segment_parameters("/some,dir/path,branch=tip"))
 
533
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
 
534
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
 
535
        self.assertEquals(("/somedir/path",
 
536
            {"ref": "heads%2Ftip", "key1": "val1"}),
 
537
            split_segment_parameters(
 
538
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
 
539
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
 
540
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
 
541
        self.assertEquals(("/", {"key1": "val1"}),
 
542
            split_segment_parameters(",key1=val1"))
 
543
        self.assertEquals(("foo/", {"key1": "val1"}),
 
544
            split_segment_parameters("foo/,key1=val1"))
 
545
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
 
546
            split_segment_parameters("foo/base,key1=val1/other/elements"))
 
547
        self.assertEquals(("foo/base,key1=val1/other/elements",
 
548
            {"key2": "val2"}), split_segment_parameters(
 
549
                "foo/base,key1=val1/other/elements,key2=val2"))
 
550
 
415
551
    def test_win32_strip_local_trailing_slash(self):
416
552
        strip = urlutils._win32_strip_local_trailing_slash
417
553
        self.assertEqual('file://', strip('file://'))
680
816
 
681
817
class TestParseURL(TestCase):
682
818
 
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'))
 
819
    def test_parse_simple(self):
 
820
        parsed = urlutils.parse_url('http://example.com:80/one')
 
821
        self.assertEquals(('http', None, None, 'example.com', 80, '/one'),
 
822
            parsed)
 
823
 
 
824
    def test_ipv6(self):
 
825
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
 
826
        self.assertEquals(('http', None, None, '1:2:3::40', None, '/one'),
 
827
            parsed)
 
828
 
 
829
    def test_ipv6_port(self):
 
830
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
 
831
        self.assertEquals(('http', None, None, '1:2:3::40', 80, '/one'),
 
832
            parsed)
 
833
 
 
834
 
 
835
class TestURL(TestCase):
 
836
 
 
837
    def test_parse_simple(self):
 
838
        parsed = urlutils.URL.from_string('http://example.com:80/one')
 
839
        self.assertEquals('http', parsed.scheme)
 
840
        self.assertIs(None, parsed.user)
 
841
        self.assertIs(None, parsed.password)
 
842
        self.assertEquals('example.com', parsed.host)
 
843
        self.assertEquals(80, parsed.port)
 
844
        self.assertEquals('/one', parsed.path)
 
845
 
 
846
    def test_ipv6(self):
 
847
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
 
848
        self.assertEquals('http', parsed.scheme)
 
849
        self.assertIs(None, parsed.port)
 
850
        self.assertIs(None, parsed.user)
 
851
        self.assertIs(None, parsed.password)
 
852
        self.assertEquals('1:2:3::40', parsed.host)
 
853
        self.assertEquals('/one', parsed.path)
 
854
 
 
855
    def test_ipv6_port(self):
 
856
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
857
        self.assertEquals('http', parsed.scheme)
 
858
        self.assertEquals('1:2:3::40', parsed.host)
 
859
        self.assertIs(None, parsed.user)
 
860
        self.assertIs(None, parsed.password)
 
861
        self.assertEquals(80, parsed.port)
 
862
        self.assertEquals('/one', parsed.path)
 
863
 
 
864
    def test_quoted(self):
 
865
        parsed = urlutils.URL.from_string(
 
866
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
 
867
        self.assertEquals(parsed.quoted_host, 'ex%41mple.com')
 
868
        self.assertEquals(parsed.host, 'exAmple.com')
 
869
        self.assertEquals(parsed.port, 2222)
 
870
        self.assertEquals(parsed.quoted_user, 'ro%62ey')
 
871
        self.assertEquals(parsed.user, 'robey')
 
872
        self.assertEquals(parsed.quoted_password, 'h%40t')
 
873
        self.assertEquals(parsed.password, 'h@t')
 
874
        self.assertEquals(parsed.path, '/path')
 
875
 
 
876
    def test_eq(self):
 
877
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
878
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
879
        self.assertEquals(parsed1, parsed2)
 
880
        self.assertEquals(parsed1, parsed1)
 
881
        parsed2.path = '/two'
 
882
        self.assertNotEquals(parsed1, parsed2)
 
883
 
 
884
    def test_repr(self):
 
885
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
886
        self.assertEquals(
 
887
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
 
888
            repr(parsed))
 
889
 
 
890
    def test_str(self):
 
891
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
892
        self.assertEquals('http://[1:2:3::40]:80/one', str(parsed))
 
893
 
 
894
    def test__combine_paths(self):
 
895
        combine = urlutils.URL._combine_paths
 
896
        self.assertEqual('/home/sarah/project/foo',
 
897
                         combine('/home/sarah', 'project/foo'))
 
898
        self.assertEqual('/etc',
 
899
                         combine('/home/sarah', '../../etc'))
 
900
        self.assertEqual('/etc',
 
901
                         combine('/home/sarah', '../../../etc'))
 
902
        self.assertEqual('/etc',
 
903
                         combine('/home/sarah', '/etc'))
 
904
 
 
905
    def test_clone(self):
 
906
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
907
        url1 = url.clone("two")
 
908
        self.assertEquals("/one/two", url1.path)
 
909
        url2 = url.clone("/two")
 
910
        self.assertEquals("/two", url2.path)
 
911
        url3 = url.clone()
 
912
        self.assertIsNot(url, url3)
 
913
        self.assertEquals(url, url3)