/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: Robert Collins
  • Date: 2010-07-04 06:22:11 UTC
  • mto: This revision was merged to the branch mainline in revision 5332.
  • Revision ID: robertc@robertcollins.net-20100704062211-tk9hw6bnsn5x47fm
``bzrlib.lsprof.profile`` will no longer silently generate bad threaded
profiles when concurrent profile requests are made. Instead the profile
requests will be serialised. Reentrant requests will now deadlock.
(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('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)
412
476
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
413
477
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
414
478
 
 
479
    def test_split_segment_parameters_raw(self):
 
480
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
 
481
        self.assertEquals(("/some/path", []),
 
482
            split_segment_parameters_raw("/some/path"))
 
483
        self.assertEquals(("/some/path", ["tip"]),
 
484
            split_segment_parameters_raw("/some/path,tip"))
 
485
        self.assertEquals(("/some,dir/path", ["tip"]),
 
486
            split_segment_parameters_raw("/some,dir/path,tip"))
 
487
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
 
488
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
 
489
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
 
490
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
 
491
        self.assertEquals(("/", ["key1=val1"]),
 
492
            split_segment_parameters_raw(",key1=val1"))
 
493
        self.assertEquals(("foo/", ["key1=val1"]),
 
494
            split_segment_parameters_raw("foo/,key1=val1"))
 
495
        self.assertEquals(("foo/base,la=bla/other/elements", []),
 
496
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
 
497
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
 
498
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
 
499
 
 
500
    def test_split_segment_parameters(self):
 
501
        split_segment_parameters = urlutils.split_segment_parameters
 
502
        self.assertEquals(("/some/path", {}),
 
503
            split_segment_parameters("/some/path"))
 
504
        self.assertEquals(("/some/path", {"branch": "tip"}),
 
505
            split_segment_parameters("/some/path,branch=tip"))
 
506
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
 
507
            split_segment_parameters("/some,dir/path,branch=tip"))
 
508
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
 
509
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
 
510
        self.assertEquals(("/somedir/path",
 
511
            {"ref": "heads%2Ftip", "key1": "val1"}),
 
512
            split_segment_parameters(
 
513
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
 
514
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
 
515
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
 
516
        self.assertEquals(("/", {"key1": "val1"}),
 
517
            split_segment_parameters(",key1=val1"))
 
518
        self.assertEquals(("foo/", {"key1": "val1"}),
 
519
            split_segment_parameters("foo/,key1=val1"))
 
520
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
 
521
            split_segment_parameters("foo/base,key1=val1/other/elements"))
 
522
        self.assertEquals(("foo/base,key1=val1/other/elements",
 
523
            {"key2": "val2"}), split_segment_parameters(
 
524
                "foo/base,key1=val1/other/elements,key2=val2"))
 
525
 
415
526
    def test_win32_strip_local_trailing_slash(self):
416
527
        strip = urlutils._win32_strip_local_trailing_slash
417
528
        self.assertEqual('file://', strip('file://'))