← 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-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
17
17
"""Tests for the urlutils wrapper."""
18
18
 
19
19
import os
20
 
import re
21
20
import sys
22
21
 
23
22
from bzrlib import osutils, urlutils, win32utils
157
156
        # Weird stuff
158
157
        # Can't have slashes or colons in the scheme
159
158
        test_one('/path/to/://foo', None)
160
 
        test_one('path:path://foo', None)
 
159
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
161
160
        # Must have more than one character for scheme
162
161
        test_one('C://foo', None)
163
162
        test_one('ab://foo', ('ab', 'foo'))
196
195
            dirname('path/to/foo/', exclude_trailing_slash=False))
197
196
        self.assertEqual('path/..', dirname('path/../foo'))
198
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'))
199
212
 
200
213
    def test_join(self):
201
214
        def test(expected, *args):
211
224
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
212
225
        test('http://foo/baz', 'http://foo', 'bar/../baz')
213
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')
214
229
 
215
230
        # Absolute paths
216
231
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
220
235
        test('http://bar/', 'http://foo', 'http://bar/')
221
236
        test('http://bar/a', 'http://foo', 'http://bar/a')
222
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')
223
241
 
224
242
        # From a base path
225
243
        test('file:///foo', 'file:///', 'foo')
271
289
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
272
290
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
273
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
 
274
337
    def test_function_type(self):
275
338
        if sys.platform == 'win32':
276
339
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
300
363
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
301
364
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
302
365
            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
 
366
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
367
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
303
368
 
304
369
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
 
370
        self.assertRaises(
 
371
            InvalidURL, from_url,
 
372
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
305
373
 
306
374
    def test_win32_local_path_to_url(self):
307
375
        to_url = urlutils._win32_local_path_to_url
408
476
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
409
477
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
410
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
 
411
526
    def test_win32_strip_local_trailing_slash(self):
412
527
        strip = urlutils._win32_strip_local_trailing_slash
413
528
        self.assertEqual('file://', strip('file://'))