/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

  • Committer: Jelmer Vernooij
  • Date: 2011-08-15 12:37:25 UTC
  • mto: (5268.8.2 switch-colocated)
  • mto: This revision was merged to the branch mainline in revision 6079.
  • Revision ID: jelmer@samba.org-20110815123725-lbhuwfc67cs23ef0
Fix URL for transport tests.

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
339
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
283
347
        self.assertEqual('file:///path/to/foo',
284
348
            to_url('/path/to/foo'))
285
349
 
 
350
        self.assertEqual('file:///path/to/foo%2Cbar',
 
351
            to_url('/path/to/foo,bar'))
 
352
 
286
353
        try:
287
354
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
288
355
        except UnicodeError:
322
389
 
323
390
        self.assertEqual('file:///', to_url('/'))
324
391
 
 
392
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
 
393
            to_url('C:/path/to/foo,bar'))
325
394
        try:
326
395
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
327
396
        except UnicodeError:
355
424
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
356
425
        self.assertEqual('/', from_url('file:///'))
357
426
 
 
427
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
 
428
        self.assertRaises(InvalidURL, from_url, 'file:///c')
358
429
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
359
430
        # Not a valid _win32 url, no drive letter
360
431
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
412
483
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
413
484
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
414
485
 
 
486
    def test_split_segment_parameters_raw(self):
 
487
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
 
488
        self.assertEquals(("/some/path", []),
 
489
            split_segment_parameters_raw("/some/path"))
 
490
        self.assertEquals(("/some/path", ["tip"]),
 
491
            split_segment_parameters_raw("/some/path,tip"))
 
492
        self.assertEquals(("/some,dir/path", ["tip"]),
 
493
            split_segment_parameters_raw("/some,dir/path,tip"))
 
494
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
 
495
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
 
496
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
 
497
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
 
498
        self.assertEquals(("/", ["key1=val1"]),
 
499
            split_segment_parameters_raw(",key1=val1"))
 
500
        self.assertEquals(("foo/", ["key1=val1"]),
 
501
            split_segment_parameters_raw("foo/,key1=val1"))
 
502
        self.assertEquals(("foo/base,la=bla/other/elements", []),
 
503
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
 
504
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
 
505
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
 
506
 
 
507
    def test_split_segment_parameters(self):
 
508
        split_segment_parameters = urlutils.split_segment_parameters
 
509
        self.assertEquals(("/some/path", {}),
 
510
            split_segment_parameters("/some/path"))
 
511
        self.assertEquals(("/some/path", {"branch": "tip"}),
 
512
            split_segment_parameters("/some/path,branch=tip"))
 
513
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
 
514
            split_segment_parameters("/some,dir/path,branch=tip"))
 
515
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
 
516
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
 
517
        self.assertEquals(("/somedir/path",
 
518
            {"ref": "heads%2Ftip", "key1": "val1"}),
 
519
            split_segment_parameters(
 
520
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
 
521
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
 
522
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
 
523
        self.assertEquals(("/", {"key1": "val1"}),
 
524
            split_segment_parameters(",key1=val1"))
 
525
        self.assertEquals(("foo/", {"key1": "val1"}),
 
526
            split_segment_parameters("foo/,key1=val1"))
 
527
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
 
528
            split_segment_parameters("foo/base,key1=val1/other/elements"))
 
529
        self.assertEquals(("foo/base,key1=val1/other/elements",
 
530
            {"key2": "val2"}), split_segment_parameters(
 
531
                "foo/base,key1=val1/other/elements,key2=val2"))
 
532
 
415
533
    def test_win32_strip_local_trailing_slash(self):
416
534
        strip = urlutils._win32_strip_local_trailing_slash
417
535
        self.assertEqual('file://', strip('file://'))
680
798
 
681
799
class TestParseURL(TestCase):
682
800
 
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'))
 
801
    def test_parse_simple(self):
 
802
        parsed = urlutils.parse_url('http://example.com:80/one')
 
803
        self.assertEquals(('http', None, None, 'example.com', 80, '/one'),
 
804
            parsed)
 
805
 
 
806
    def test_ipv6(self):
 
807
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
 
808
        self.assertEquals(('http', None, None, '1:2:3::40', None, '/one'),
 
809
            parsed)
 
810
 
 
811
    def test_ipv6_port(self):
 
812
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
 
813
        self.assertEquals(('http', None, None, '1:2:3::40', 80, '/one'),
 
814
            parsed)
 
815
 
 
816
 
 
817
class TestURL(TestCase):
 
818
 
 
819
    def test_parse_simple(self):
 
820
        parsed = urlutils.URL.from_string('http://example.com:80/one')
 
821
        self.assertEquals('http', parsed.scheme)
 
822
        self.assertIs(None, parsed.user)
 
823
        self.assertIs(None, parsed.password)
 
824
        self.assertEquals('example.com', parsed.host)
 
825
        self.assertEquals(80, parsed.port)
 
826
        self.assertEquals('/one', parsed.path)
 
827
 
 
828
    def test_ipv6(self):
 
829
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
 
830
        self.assertEquals('http', parsed.scheme)
 
831
        self.assertIs(None, parsed.port)
 
832
        self.assertIs(None, parsed.user)
 
833
        self.assertIs(None, parsed.password)
 
834
        self.assertEquals('1:2:3::40', parsed.host)
 
835
        self.assertEquals('/one', parsed.path)
 
836
 
 
837
    def test_ipv6_port(self):
 
838
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
839
        self.assertEquals('http', parsed.scheme)
 
840
        self.assertEquals('1:2:3::40', parsed.host)
 
841
        self.assertIs(None, parsed.user)
 
842
        self.assertIs(None, parsed.password)
 
843
        self.assertEquals(80, parsed.port)
 
844
        self.assertEquals('/one', parsed.path)
 
845
 
 
846
    def test_quoted(self):
 
847
        parsed = urlutils.URL.from_string(
 
848
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
 
849
        self.assertEquals(parsed.quoted_host, 'ex%41mple.com')
 
850
        self.assertEquals(parsed.host, 'exAmple.com')
 
851
        self.assertEquals(parsed.port, 2222)
 
852
        self.assertEquals(parsed.quoted_user, 'ro%62ey')
 
853
        self.assertEquals(parsed.user, 'robey')
 
854
        self.assertEquals(parsed.quoted_password, 'h%40t')
 
855
        self.assertEquals(parsed.password, 'h@t')
 
856
        self.assertEquals(parsed.path, '/path')
 
857
 
 
858
    def test_eq(self):
 
859
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
860
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
861
        self.assertEquals(parsed1, parsed2)
 
862
        self.assertEquals(parsed1, parsed1)
 
863
        parsed2.path = '/two'
 
864
        self.assertNotEquals(parsed1, parsed2)
 
865
 
 
866
    def test_repr(self):
 
867
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
868
        self.assertEquals(
 
869
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
 
870
            repr(parsed))
 
871
 
 
872
    def test_str(self):
 
873
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
874
        self.assertEquals('http://[1:2:3::40]:80/one', str(parsed))
 
875
 
 
876
    def test__combine_paths(self):
 
877
        combine = urlutils.URL._combine_paths
 
878
        self.assertEqual('/home/sarah/project/foo',
 
879
                         combine('/home/sarah', 'project/foo'))
 
880
        self.assertEqual('/etc',
 
881
                         combine('/home/sarah', '../../etc'))
 
882
        self.assertEqual('/etc',
 
883
                         combine('/home/sarah', '../../../etc'))
 
884
        self.assertEqual('/etc',
 
885
                         combine('/home/sarah', '/etc'))
 
886
 
 
887
    def test_clone(self):
 
888
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
889
        url1 = url.clone("two")
 
890
        self.assertEquals("/one/two", url1.path)
 
891
        url2 = url.clone("/two")
 
892
        self.assertEquals("/two", url2.path)
 
893
        url3 = url.clone()
 
894
        self.assertIsNot(url, url3)
 
895
        self.assertEquals(url, url3)