← 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: 2010-05-11 11:47:36 UTC
  • mfrom: (5200.3.8 lock_return)
  • Revision ID: pqm@pqm.ubuntu.com-20100511114736-mc1sq9zyo3vufec7
(lifeless) Provide a consistent interface to Tree, Branch,
 Repository where lock methods return an object with an unlock method to
 unlock the lock. This breaks the API for Branch,
 Repository on their lock_write methods. (Robert Collins)

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('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
457
376
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
458
377
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
459
378
        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')
466
379
 
467
380
    def test_split(self):
468
381
        # Test bzrlib.urlutils.split()
499
412
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
500
413
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
501
414
 
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
 
 
551
415
    def test_win32_strip_local_trailing_slash(self):
552
416
        strip = urlutils._win32_strip_local_trailing_slash
553
417
        self.assertEqual('file://', strip('file://'))
816
680
 
817
681
class TestParseURL(TestCase):
818
682
 
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)
 
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'))