← 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: Patch Queue Manager
  • Date: 2013-05-23 10:35:23 UTC
  • mfrom: (6574.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20130523103523-2wt6jmauja1n1vdt
(jameinel) Merge bzr/2.5 into trunk. (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2006-2012 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the urlutils wrapper."""
18
18
 
19
19
import os
20
 
import re
21
20
import sys
22
21
 
23
 
from bzrlib import osutils, urlutils
24
 
import bzrlib
25
 
from bzrlib.errors import InvalidURL, InvalidURLJoin
 
22
from bzrlib import osutils, urlutils, win32utils
 
23
from bzrlib.errors import (
 
24
    InvalidURL,
 
25
    InvalidURLJoin,
 
26
    InvalidRebaseURLs,
 
27
    PathNotChild,
 
28
    )
26
29
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
27
30
 
28
31
 
29
32
class TestUrlToPath(TestCase):
30
 
    
 
33
 
31
34
    def test_basename(self):
32
35
        # bzrlib.urlutils.basename
33
36
        # Test bzrlib.urlutils.split()
82
85
 
83
86
        # Local paths are assumed to *not* be escaped at all
84
87
        try:
85
 
            u'uni/\xb5'.encode(bzrlib.user_encoding)
 
88
            u'uni/\xb5'.encode(osutils.get_user_encoding())
86
89
        except UnicodeError:
87
 
            # locale cannot handle unicode 
 
90
            # locale cannot handle unicode
88
91
            pass
89
92
        else:
90
93
            norm_file('uni/%C2%B5', u'uni/\xb5')
115
118
        eq('http://host/ab/%C2%B5/%C2%B5',
116
119
            normalize_url(u'http://host/ab/%C2%B5/\xb5'))
117
120
 
 
121
        # Unescape characters that don't need to be escaped
 
122
        eq('http://host/~bob%2525-._',
 
123
                normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
 
124
        eq('http://host/~bob%2525-._',
 
125
                normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
 
126
 
118
127
        # Normalize verifies URLs when they are not unicode
119
128
        # (indicating they did not come from the user)
120
129
        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
152
161
        # Weird stuff
153
162
        # Can't have slashes or colons in the scheme
154
163
        test_one('/path/to/://foo', None)
155
 
        test_one('path:path://foo', None)
 
164
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
156
165
        # Must have more than one character for scheme
157
166
        test_one('C://foo', None)
158
167
        test_one('ab://foo', ('ab', 'foo'))
191
200
            dirname('path/to/foo/', exclude_trailing_slash=False))
192
201
        self.assertEqual('path/..', dirname('path/../foo'))
193
202
        self.assertEqual('../path', dirname('../path/foo'))
 
203
    
 
204
    def test_is_url(self):
 
205
        self.assertTrue(urlutils.is_url('http://foo/bar'))
 
206
        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))
 
207
        self.assertTrue(urlutils.is_url('lp:foo/bar'))
 
208
        self.assertTrue(urlutils.is_url('file:///foo/bar'))
 
209
        self.assertFalse(urlutils.is_url(''))
 
210
        self.assertFalse(urlutils.is_url('foo'))
 
211
        self.assertFalse(urlutils.is_url('foo/bar'))
 
212
        self.assertFalse(urlutils.is_url('/foo'))
 
213
        self.assertFalse(urlutils.is_url('/foo/bar'))
 
214
        self.assertFalse(urlutils.is_url('C:/'))
 
215
        self.assertFalse(urlutils.is_url('C:/foo'))
 
216
        self.assertFalse(urlutils.is_url('C:/foo/bar'))
194
217
 
195
218
    def test_join(self):
196
219
        def test(expected, *args):
197
220
            joined = urlutils.join(*args)
198
221
            self.assertEqual(expected, joined)
199
222
 
200
 
        # Test a single element
201
 
        test('foo', 'foo')
202
 
 
203
223
        # Test relative path joining
 
224
        test('foo', 'foo') # relative fragment with nothing is preserved.
204
225
        test('foo/bar', 'foo', 'bar')
205
226
        test('http://foo/bar', 'http://foo', 'bar')
206
227
        test('http://foo/bar', 'http://foo', '.', 'bar')
207
228
        test('http://foo/baz', 'http://foo', 'bar', '../baz')
208
229
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
209
230
        test('http://foo/baz', 'http://foo', 'bar/../baz')
 
231
        test('http://foo/baz', 'http://foo/bar/', '../baz')
 
232
        test('lp:foo/bar', 'lp:foo', 'bar')
 
233
        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')
210
234
 
211
235
        # Absolute paths
 
236
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
212
237
        test('http://bar', 'http://foo', 'http://bar')
213
238
        test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')
214
239
        test('file:///bar', 'foo', 'file:///bar')
 
240
        test('http://bar/', 'http://foo', 'http://bar/')
 
241
        test('http://bar/a', 'http://foo', 'http://bar/a')
 
242
        test('http://bar/a/', 'http://foo', 'http://bar/a/')
 
243
        test('lp:bar', 'http://foo', 'lp:bar')
 
244
        test('lp:bar', 'lp:foo', 'lp:bar')
 
245
        test('file:///stuff', 'lp:foo', 'file:///stuff')
215
246
 
216
247
        # From a base path
217
248
        test('file:///foo', 'file:///', 'foo')
218
249
        test('file:///bar/foo', 'file:///bar/', 'foo')
219
250
        test('http://host/foo', 'http://host/', 'foo')
220
251
        test('http://host/', 'http://host', '')
221
 
        
 
252
 
222
253
        # Invalid joinings
223
254
        # Cannot go above root
 
255
        # Implicitly at root:
224
256
        self.assertRaises(InvalidURLJoin, urlutils.join,
225
257
                'http://foo', '../baz')
 
258
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
259
                'http://foo', '/..')
 
260
        # Joining from a path explicitly under the root.
 
261
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
262
                'http://foo/a', '../../b')
 
263
 
 
264
    def test_joinpath(self):
 
265
        def test(expected, *args):
 
266
            joined = urlutils.joinpath(*args)
 
267
            self.assertEqual(expected, joined)
 
268
 
 
269
        # Test a single element
 
270
        test('foo', 'foo')
 
271
 
 
272
        # Test relative path joining
 
273
        test('foo/bar', 'foo', 'bar')
 
274
        test('foo/bar', 'foo', '.', 'bar')
 
275
        test('foo/baz', 'foo', 'bar', '../baz')
 
276
        test('foo/bar/baz', 'foo', 'bar/baz')
 
277
        test('foo/baz', 'foo', 'bar/../baz')
 
278
 
 
279
        # Test joining to an absolute path
 
280
        test('/foo', '/foo')
 
281
        test('/foo', '/foo', '.')
 
282
        test('/foo/bar', '/foo', 'bar')
 
283
        test('/', '/foo', '..')
 
284
 
 
285
        # Test joining with an absolute path
 
286
        test('/bar', 'foo', '/bar')
 
287
 
 
288
        # Test joining to a path with a trailing slash
 
289
        test('foo/bar', 'foo/', 'bar')
 
290
 
 
291
        # Invalid joinings
 
292
        # Cannot go above root
 
293
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
 
294
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
 
295
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
 
296
 
 
297
    def test_join_segment_parameters_raw(self):
 
298
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
 
299
        self.assertEquals("/somedir/path", 
 
300
            join_segment_parameters_raw("/somedir/path"))
 
301
        self.assertEquals("/somedir/path,rawdata", 
 
302
            join_segment_parameters_raw("/somedir/path", "rawdata"))
 
303
        self.assertRaises(InvalidURLJoin,
 
304
            join_segment_parameters_raw, "/somedir/path",
 
305
                "rawdata1,rawdata2,rawdata3")
 
306
        self.assertEquals("/somedir/path,bla,bar",
 
307
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
 
308
        self.assertEquals("/somedir,exist=some/path,bla,bar",
 
309
            join_segment_parameters_raw("/somedir,exist=some/path",
 
310
                "bla", "bar"))
 
311
        self.assertRaises(TypeError, join_segment_parameters_raw, 
 
312
            "/somepath", 42)
 
313
 
 
314
    def test_join_segment_parameters(self):
 
315
        join_segment_parameters = urlutils.join_segment_parameters
 
316
        self.assertEquals("/somedir/path", 
 
317
            join_segment_parameters("/somedir/path", {}))
 
318
        self.assertEquals("/somedir/path,key1=val1", 
 
319
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
 
320
        self.assertRaises(InvalidURLJoin,
 
321
            join_segment_parameters, "/somedir/path",
 
322
            {"branch": "brr,brr,brr"})
 
323
        self.assertRaises(InvalidURLJoin,
 
324
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
 
325
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
326
            join_segment_parameters("/somedir/path", {
 
327
                "key1": "val1", "key2": "val2"}))
 
328
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
329
            join_segment_parameters("/somedir/path,key1=val1", {
 
330
                "key2": "val2"}))
 
331
        self.assertEquals("/somedir/path,key1=val2",
 
332
            join_segment_parameters("/somedir/path,key1=val1", {
 
333
                "key1": "val2"}))
 
334
        self.assertEquals("/somedir,exist=some/path,key1=val1",
 
335
            join_segment_parameters("/somedir,exist=some/path",
 
336
                {"key1": "val1"}))
 
337
        self.assertEquals("/,key1=val1,key2=val2",
 
338
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
 
339
        self.assertRaises(TypeError,
 
340
            join_segment_parameters, "/,key1=val1", {"foo": 42})
226
341
 
227
342
    def test_function_type(self):
228
343
        if sys.platform == 'win32':
229
 
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
230
 
            self.assertEqual(urlutils._win32_local_path_from_url, urlutils.local_path_from_url)
 
344
            self.assertEqual(urlutils._win32_local_path_to_url,
 
345
                urlutils.local_path_to_url)
 
346
            self.assertEqual(urlutils._win32_local_path_from_url,
 
347
                urlutils.local_path_from_url)
231
348
        else:
232
 
            self.assertEqual(urlutils._posix_local_path_to_url, urlutils.local_path_to_url)
233
 
            self.assertEqual(urlutils._posix_local_path_from_url, urlutils.local_path_from_url)
 
349
            self.assertEqual(urlutils._posix_local_path_to_url,
 
350
                urlutils.local_path_to_url)
 
351
            self.assertEqual(urlutils._posix_local_path_from_url,
 
352
                urlutils.local_path_from_url)
234
353
 
235
354
    def test_posix_local_path_to_url(self):
236
355
        to_url = urlutils._posix_local_path_to_url
237
356
        self.assertEqual('file:///path/to/foo',
238
357
            to_url('/path/to/foo'))
239
358
 
 
359
        self.assertEqual('file:///path/to/foo%2Cbar',
 
360
            to_url('/path/to/foo,bar'))
 
361
 
240
362
        try:
241
363
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
242
364
        except UnicodeError:
243
365
            raise TestSkipped("local encoding cannot handle unicode")
244
366
 
245
367
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
368
        self.assertFalse(isinstance(result, unicode))
246
369
 
247
370
    def test_posix_local_path_from_url(self):
248
371
        from_url = urlutils._posix_local_path_from_url
249
372
        self.assertEqual('/path/to/foo',
250
373
            from_url('file:///path/to/foo'))
 
374
        self.assertEqual('/path/to/foo',
 
375
            from_url('file:///path/to/foo,branch=foo'))
251
376
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
252
377
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
253
378
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
254
379
            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
 
380
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
381
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
255
382
 
256
383
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
 
384
        self.assertRaises(
 
385
            InvalidURL, from_url,
 
386
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
257
387
 
258
388
    def test_win32_local_path_to_url(self):
259
389
        to_url = urlutils._win32_local_path_to_url
268
398
        self.assertEqual('file:///C:/path/to/f%20oo',
269
399
            to_url('C:/path/to/f oo'))
270
400
 
 
401
        self.assertEqual('file:///', to_url('/'))
 
402
 
 
403
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
 
404
            to_url('C:/path/to/foo,bar'))
271
405
        try:
272
406
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
273
407
        except UnicodeError:
274
408
            raise TestSkipped("local encoding cannot handle unicode")
275
409
 
276
410
        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
411
        self.assertFalse(isinstance(result, unicode))
 
412
 
 
413
    def test_win32_unc_path_to_url(self):
 
414
        to_url = urlutils._win32_local_path_to_url
 
415
        self.assertEqual('file://HOST/path',
 
416
            to_url(r'\\HOST\path'))
 
417
        self.assertEqual('file://HOST/path',
 
418
            to_url('//HOST/path'))
 
419
 
 
420
        try:
 
421
            result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')
 
422
        except UnicodeError:
 
423
            raise TestSkipped("local encoding cannot handle unicode")
 
424
 
 
425
        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
426
        self.assertFalse(isinstance(result, unicode))
277
427
 
278
428
    def test_win32_local_path_from_url(self):
279
429
        from_url = urlutils._win32_local_path_from_url
283
433
            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
284
434
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
285
435
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
 
436
        self.assertEqual('/', from_url('file:///'))
 
437
        self.assertEqual('C:/path/to/foo',
 
438
            from_url('file:///C|/path/to/foo,branch=foo'))
286
439
 
 
440
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
 
441
        self.assertRaises(InvalidURL, from_url, 'file:///c')
287
442
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
288
443
        # Not a valid _win32 url, no drive letter
289
444
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
290
445
 
291
 
    def test__win32_extract_drive_letter(self):
 
446
    def test_win32_unc_path_from_url(self):
 
447
        from_url = urlutils._win32_local_path_from_url
 
448
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
 
449
        self.assertEqual('//HOST/path',
 
450
            from_url('file://HOST/path,branch=foo'))
 
451
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
 
452
        # we want to use only 2 slashes
 
453
        # Firefox understand only 5 slashes in URL, but it's ugly
 
454
        self.assertRaises(InvalidURL, from_url, 'file:////HOST/path')
 
455
        self.assertRaises(InvalidURL, from_url, 'file://///HOST/path')
 
456
        self.assertRaises(InvalidURL, from_url, 'file://////HOST/path')
 
457
        # check for file://C:/ instead of file:///C:/
 
458
        self.assertRaises(InvalidURL, from_url, 'file://C:/path')
 
459
 
 
460
    def test_win32_extract_drive_letter(self):
292
461
        extract = urlutils._win32_extract_drive_letter
293
462
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
294
463
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
295
464
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
 
465
        # Root drives without slash treated as invalid, see bug #841322
 
466
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
 
467
        self.assertRaises(InvalidURL, extract, 'file://', '/C:')
 
468
        # Invalid without drive separator or following forward slash
 
469
        self.assertRaises(InvalidURL, extract, 'file://', '/C')
 
470
        self.assertRaises(InvalidURL, extract, 'file://', '/C:ool')
296
471
 
297
472
    def test_split(self):
298
473
        # Test bzrlib.urlutils.split()
329
504
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
330
505
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
331
506
 
332
 
    def test__win32_strip_local_trailing_slash(self):
 
507
    def test_split_segment_parameters_raw(self):
 
508
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
 
509
        # Check relative references with absolute paths
 
510
        self.assertEquals(("/some/path", []),
 
511
            split_segment_parameters_raw("/some/path"))
 
512
        self.assertEquals(("/some/path", ["tip"]),
 
513
            split_segment_parameters_raw("/some/path,tip"))
 
514
        self.assertEquals(("/some,dir/path", ["tip"]),
 
515
            split_segment_parameters_raw("/some,dir/path,tip"))
 
516
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
 
517
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
 
518
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
 
519
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
 
520
        # Check relative references with relative paths
 
521
        self.assertEquals(("", ["key1=val1"]),
 
522
            split_segment_parameters_raw(",key1=val1"))
 
523
        self.assertEquals(("foo/", ["key1=val1"]),
 
524
            split_segment_parameters_raw("foo/,key1=val1"))
 
525
        self.assertEquals(("foo", ["key1=val1"]),
 
526
            split_segment_parameters_raw("foo,key1=val1"))
 
527
        self.assertEquals(("foo/base,la=bla/other/elements", []),
 
528
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
 
529
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
 
530
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
 
531
        # TODO: Check full URLs as well as relative references
 
532
 
 
533
    def test_split_segment_parameters(self):
 
534
        split_segment_parameters = urlutils.split_segment_parameters
 
535
        # Check relative references with absolute paths
 
536
        self.assertEquals(("/some/path", {}),
 
537
            split_segment_parameters("/some/path"))
 
538
        self.assertEquals(("/some/path", {"branch": "tip"}),
 
539
            split_segment_parameters("/some/path,branch=tip"))
 
540
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
 
541
            split_segment_parameters("/some,dir/path,branch=tip"))
 
542
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
 
543
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
 
544
        self.assertEquals(("/somedir/path",
 
545
            {"ref": "heads%2Ftip", "key1": "val1"}),
 
546
            split_segment_parameters(
 
547
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
 
548
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
 
549
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
 
550
        # Check relative references with relative paths
 
551
        self.assertEquals(("", {"key1": "val1"}),
 
552
            split_segment_parameters(",key1=val1"))
 
553
        self.assertEquals(("foo/", {"key1": "val1"}),
 
554
            split_segment_parameters("foo/,key1=val1"))
 
555
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
 
556
            split_segment_parameters("foo/base,key1=val1/other/elements"))
 
557
        self.assertEquals(("foo/base,key1=val1/other/elements",
 
558
            {"key2": "val2"}), split_segment_parameters(
 
559
                "foo/base,key1=val1/other/elements,key2=val2"))
 
560
        # TODO: Check full URLs as well as relative references
 
561
 
 
562
    def test_win32_strip_local_trailing_slash(self):
333
563
        strip = urlutils._win32_strip_local_trailing_slash
334
564
        self.assertEqual('file://', strip('file://'))
335
565
        self.assertEqual('file:///', strip('file:///'))
416
646
    def test_escape(self):
417
647
        self.assertEqual('%25', urlutils.escape('%'))
418
648
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
 
649
        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
 
650
 
 
651
    def test_escape_tildes(self):
 
652
        self.assertEqual('~foo', urlutils.escape('~foo'))
419
653
 
420
654
    def test_unescape(self):
421
655
        self.assertEqual('%', urlutils.unescape('%25'))
433
667
        def test(expected, base, other):
434
668
            result = urlutils.relative_url(base, other)
435
669
            self.assertEqual(expected, result)
436
 
            
 
670
 
437
671
        test('a', 'http://host/', 'http://host/a')
438
672
        test('http://entirely/different', 'sftp://host/branch',
439
673
                    'http://entirely/different')
448
682
                    'sftp://host/home/jelmer/branch/2b')
449
683
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
450
684
                    'http://host/home/jelmer/branch/feature/%2b')
451
 
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/', 
 
685
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
452
686
                    'http://host/home/jelmer/branch/feature/2b')
453
687
        # relative_url should preserve a trailing slash
454
688
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
466
700
        #test('.', 'http://host/', 'http://host')
467
701
        test('http://host', 'http://host/', 'http://host')
468
702
 
 
703
        # On Windows file:///C:/path/to and file:///D:/other/path
 
704
        # should not use relative url over the non-existent '/' directory.
 
705
        if sys.platform == 'win32':
 
706
            # on the same drive
 
707
            test('../../other/path',
 
708
                'file:///C:/path/to', 'file:///C:/other/path')
 
709
            #~next two tests is failed, i.e. urlutils.relative_url expects
 
710
            #~to see normalized file URLs?
 
711
            #~test('../../other/path',
 
712
            #~    'file:///C:/path/to', 'file:///c:/other/path')
 
713
            #~test('../../other/path',
 
714
            #~    'file:///C:/path/to', 'file:///C|/other/path')
 
715
 
 
716
            # check UNC paths too
 
717
            test('../../other/path',
 
718
                'file://HOST/base/path/to', 'file://HOST/base/other/path')
 
719
            # on different drives
 
720
            test('file:///D:/other/path',
 
721
                'file:///C:/path/to', 'file:///D:/other/path')
 
722
            # TODO: strictly saying in UNC path //HOST/base is full analog
 
723
            # of drive letter for hard disk, and this situation is also
 
724
            # should be exception from rules. [bialix 20071221]
 
725
 
469
726
 
470
727
class TestCwdToURL(TestCaseInTempDir):
471
 
    """Test that local_path_to_url works base on the cwd"""
 
728
    """Test that local_path_to_url works based on the cwd"""
472
729
 
473
730
    def test_dot(self):
474
731
        # This test will fail if getcwd is not ascii
479
736
        self.assertEndsWith(url, '/mytest')
480
737
 
481
738
    def test_non_ascii(self):
 
739
        if win32utils.winver == 'Windows 98':
 
740
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
 
741
 
482
742
        try:
483
743
            os.mkdir(u'dod\xe9')
484
744
        except UnicodeError:
486
746
 
487
747
        os.chdir(u'dod\xe9')
488
748
 
489
 
        # On Mac OSX this directory is actually: 
 
749
        # On Mac OSX this directory is actually:
490
750
        #   u'/dode\u0301' => '/dode\xcc\x81
491
 
        # but we should normalize it back to 
 
751
        # but we should normalize it back to
492
752
        #   u'/dod\xe9' => '/dod\xc3\xa9'
493
753
        url = urlutils.local_path_to_url('.')
494
754
        self.assertEndsWith(url, '/dod%C3%A9')
 
755
 
 
756
 
 
757
class TestDeriveToLocation(TestCase):
 
758
    """Test that the mapping of FROM_LOCATION to TO_LOCATION works."""
 
759
 
 
760
    def test_to_locations_derived_from_paths(self):
 
761
        derive = urlutils.derive_to_location
 
762
        self.assertEqual("bar", derive("bar"))
 
763
        self.assertEqual("bar", derive("../bar"))
 
764
        self.assertEqual("bar", derive("/foo/bar"))
 
765
        self.assertEqual("bar", derive("c:/foo/bar"))
 
766
        self.assertEqual("bar", derive("c:bar"))
 
767
 
 
768
    def test_to_locations_derived_from_urls(self):
 
769
        derive = urlutils.derive_to_location
 
770
        self.assertEqual("bar", derive("http://foo/bar"))
 
771
        self.assertEqual("bar", derive("bzr+ssh://foo/bar"))
 
772
        self.assertEqual("foo-bar", derive("lp:foo-bar"))
 
773
 
 
774
 
 
775
class TestRebaseURL(TestCase):
 
776
    """Test the behavior of rebase_url."""
 
777
 
 
778
    def test_non_relative(self):
 
779
        result = urlutils.rebase_url('file://foo', 'file://foo',
 
780
                                     'file://foo/bar')
 
781
        self.assertEqual('file://foo', result)
 
782
        result = urlutils.rebase_url('/foo', 'file://foo',
 
783
                                     'file://foo/bar')
 
784
        self.assertEqual('/foo', result)
 
785
 
 
786
    def test_different_ports(self):
 
787
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
788
                              'foo', 'http://bar:80', 'http://bar:81')
 
789
        self.assertEqual(str(e), "URLs differ by more than path:"
 
790
                         " 'http://bar:80' and 'http://bar:81'")
 
791
 
 
792
    def test_different_hosts(self):
 
793
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
794
                              'foo', 'http://bar', 'http://baz')
 
795
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
 
796
                         " and 'http://baz'")
 
797
 
 
798
    def test_different_protocol(self):
 
799
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
800
                              'foo', 'http://bar', 'ftp://bar')
 
801
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
 
802
                         " and 'ftp://bar'")
 
803
 
 
804
    def test_rebase_success(self):
 
805
        self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',
 
806
                         'http://baz/qux'))
 
807
        self.assertEqual('qux/bar', urlutils.rebase_url('bar',
 
808
                         'http://baz/qux', 'http://baz/'))
 
809
        self.assertEqual('.', urlutils.rebase_url('foo',
 
810
                         'http://bar/', 'http://bar/foo/'))
 
811
        self.assertEqual('qux/bar', urlutils.rebase_url('../bar',
 
812
                         'http://baz/qux/foo', 'http://baz/'))
 
813
 
 
814
    def test_determine_relative_path(self):
 
815
        self.assertEqual('../../baz/bar',
 
816
                         urlutils.determine_relative_path(
 
817
                         '/qux/quxx', '/baz/bar'))
 
818
        self.assertEqual('..',
 
819
                         urlutils.determine_relative_path(
 
820
                         '/bar/baz', '/bar'))
 
821
        self.assertEqual('baz',
 
822
                         urlutils.determine_relative_path(
 
823
                         '/bar', '/bar/baz'))
 
824
        self.assertEqual('.', urlutils.determine_relative_path(
 
825
                         '/bar', '/bar'))
 
826
 
 
827
 
 
828
class TestParseURL(TestCase):
 
829
 
 
830
    def test_parse_simple(self):
 
831
        parsed = urlutils.parse_url('http://example.com:80/one')
 
832
        self.assertEquals(('http', None, None, 'example.com', 80, '/one'),
 
833
            parsed)
 
834
 
 
835
    def test_ipv6(self):
 
836
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
 
837
        self.assertEquals(('http', None, None, '1:2:3::40', None, '/one'),
 
838
            parsed)
 
839
 
 
840
    def test_ipv6_port(self):
 
841
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
 
842
        self.assertEquals(('http', None, None, '1:2:3::40', 80, '/one'),
 
843
            parsed)
 
844
 
 
845
 
 
846
class TestURL(TestCase):
 
847
 
 
848
    def test_parse_simple(self):
 
849
        parsed = urlutils.URL.from_string('http://example.com:80/one')
 
850
        self.assertEquals('http', parsed.scheme)
 
851
        self.assertIs(None, parsed.user)
 
852
        self.assertIs(None, parsed.password)
 
853
        self.assertEquals('example.com', parsed.host)
 
854
        self.assertEquals(80, parsed.port)
 
855
        self.assertEquals('/one', parsed.path)
 
856
 
 
857
    def test_ipv6(self):
 
858
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
 
859
        self.assertEquals('http', parsed.scheme)
 
860
        self.assertIs(None, parsed.port)
 
861
        self.assertIs(None, parsed.user)
 
862
        self.assertIs(None, parsed.password)
 
863
        self.assertEquals('1:2:3::40', parsed.host)
 
864
        self.assertEquals('/one', parsed.path)
 
865
 
 
866
    def test_ipv6_port(self):
 
867
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
868
        self.assertEquals('http', parsed.scheme)
 
869
        self.assertEquals('1:2:3::40', parsed.host)
 
870
        self.assertIs(None, parsed.user)
 
871
        self.assertIs(None, parsed.password)
 
872
        self.assertEquals(80, parsed.port)
 
873
        self.assertEquals('/one', parsed.path)
 
874
 
 
875
    def test_quoted(self):
 
876
        parsed = urlutils.URL.from_string(
 
877
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
 
878
        self.assertEquals(parsed.quoted_host, 'ex%41mple.com')
 
879
        self.assertEquals(parsed.host, 'exAmple.com')
 
880
        self.assertEquals(parsed.port, 2222)
 
881
        self.assertEquals(parsed.quoted_user, 'ro%62ey')
 
882
        self.assertEquals(parsed.user, 'robey')
 
883
        self.assertEquals(parsed.quoted_password, 'h%40t')
 
884
        self.assertEquals(parsed.password, 'h@t')
 
885
        self.assertEquals(parsed.path, '/path')
 
886
 
 
887
    def test_eq(self):
 
888
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
889
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
890
        self.assertEquals(parsed1, parsed2)
 
891
        self.assertEquals(parsed1, parsed1)
 
892
        parsed2.path = '/two'
 
893
        self.assertNotEquals(parsed1, parsed2)
 
894
 
 
895
    def test_repr(self):
 
896
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
897
        self.assertEquals(
 
898
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
 
899
            repr(parsed))
 
900
 
 
901
    def test_str(self):
 
902
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
903
        self.assertEquals('http://[1:2:3::40]:80/one', str(parsed))
 
904
 
 
905
    def test__combine_paths(self):
 
906
        combine = urlutils.URL._combine_paths
 
907
        self.assertEqual('/home/sarah/project/foo',
 
908
                         combine('/home/sarah', 'project/foo'))
 
909
        self.assertEqual('/etc',
 
910
                         combine('/home/sarah', '../../etc'))
 
911
        self.assertEqual('/etc',
 
912
                         combine('/home/sarah', '../../../etc'))
 
913
        self.assertEqual('/etc',
 
914
                         combine('/home/sarah', '/etc'))
 
915
 
 
916
    def test_clone(self):
 
917
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
918
        url1 = url.clone("two")
 
919
        self.assertEquals("/one/two", url1.path)
 
920
        url2 = url.clone("/two")
 
921
        self.assertEquals("/two", url2.path)
 
922
        url3 = url.clone()
 
923
        self.assertIsNot(url, url3)
 
924
        self.assertEquals(url, url3)
 
925
 
 
926
 
 
927
class TestFileRelpath(TestCase):
 
928
 
 
929
    # GZ 2011-11-18: A way to override all path handling functions to one
 
930
    #                platform or another for testing would be nice.
 
931
 
 
932
    def _with_posix_paths(self):
 
933
        self.overrideAttr(urlutils, "local_path_from_url",
 
934
            urlutils._posix_local_path_from_url)
 
935
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH", len("file:///"))
 
936
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
 
937
        self.overrideAttr(osutils, "abspath", osutils._posix_abspath)
 
938
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
 
939
        self.overrideAttr(osutils, "pathjoin", osutils.posixpath.join)
 
940
        self.overrideAttr(osutils, "split", osutils.posixpath.split)
 
941
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 1)
 
942
 
 
943
    def _with_win32_paths(self):
 
944
        self.overrideAttr(urlutils, "local_path_from_url",
 
945
            urlutils._win32_local_path_from_url)
 
946
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH",
 
947
            urlutils.WIN32_MIN_ABS_FILEURL_LENGTH)
 
948
        self.overrideAttr(osutils, "abspath", osutils._win32_abspath)
 
949
        self.overrideAttr(osutils, "normpath", osutils._win32_normpath)
 
950
        self.overrideAttr(osutils, "pathjoin", osutils._win32_pathjoin)
 
951
        self.overrideAttr(osutils, "split", osutils.ntpath.split)
 
952
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 3)
 
953
 
 
954
    def test_same_url_posix(self):
 
955
        self._with_posix_paths()
 
956
        self.assertEquals("",
 
957
            urlutils.file_relpath("file:///a", "file:///a"))
 
958
        self.assertEquals("",
 
959
            urlutils.file_relpath("file:///a", "file:///a/"))
 
960
        self.assertEquals("",
 
961
            urlutils.file_relpath("file:///a/", "file:///a"))
 
962
 
 
963
    def test_same_url_win32(self):
 
964
        self._with_win32_paths()
 
965
        self.assertEquals("",
 
966
            urlutils.file_relpath("file:///A:/", "file:///A:/"))
 
967
        self.assertEquals("",
 
968
            urlutils.file_relpath("file:///A|/", "file:///A:/"))
 
969
        self.assertEquals("",
 
970
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
 
971
        self.assertEquals("",
 
972
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
 
973
        self.assertEquals("",
 
974
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
 
975
 
 
976
    def test_child_posix(self):
 
977
        self._with_posix_paths()
 
978
        self.assertEquals("b",
 
979
            urlutils.file_relpath("file:///a", "file:///a/b"))
 
980
        self.assertEquals("b",
 
981
            urlutils.file_relpath("file:///a/", "file:///a/b"))
 
982
        self.assertEquals("b/c",
 
983
            urlutils.file_relpath("file:///a", "file:///a/b/c"))
 
984
 
 
985
    def test_child_win32(self):
 
986
        self._with_win32_paths()
 
987
        self.assertEquals("b",
 
988
            urlutils.file_relpath("file:///A:/", "file:///A:/b"))
 
989
        self.assertEquals("b",
 
990
            urlutils.file_relpath("file:///A|/", "file:///A:/b"))
 
991
        self.assertEquals("c",
 
992
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
 
993
        self.assertEquals("c",
 
994
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
 
995
        self.assertEquals("c/d",
 
996
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
 
997
 
 
998
    def test_sibling_posix(self):
 
999
        self._with_posix_paths()
 
1000
        self.assertRaises(PathNotChild,
 
1001
            urlutils.file_relpath, "file:///a/b", "file:///a/c")
 
1002
        self.assertRaises(PathNotChild,
 
1003
            urlutils.file_relpath, "file:///a/b/", "file:///a/c")
 
1004
        self.assertRaises(PathNotChild,
 
1005
            urlutils.file_relpath, "file:///a/b/", "file:///a/c/")
 
1006
 
 
1007
    def test_sibling_win32(self):
 
1008
        self._with_win32_paths()
 
1009
        self.assertRaises(PathNotChild,
 
1010
            urlutils.file_relpath, "file:///A:/b", "file:///A:/c")
 
1011
        self.assertRaises(PathNotChild,
 
1012
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c")
 
1013
        self.assertRaises(PathNotChild,
 
1014
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c/")
 
1015
 
 
1016
    def test_parent_posix(self):
 
1017
        self._with_posix_paths()
 
1018
        self.assertRaises(PathNotChild,
 
1019
            urlutils.file_relpath, "file:///a/b", "file:///a")
 
1020
        self.assertRaises(PathNotChild,
 
1021
            urlutils.file_relpath, "file:///a/b", "file:///a/")
 
1022
 
 
1023
    def test_parent_win32(self):
 
1024
        self._with_win32_paths()
 
1025
        self.assertRaises(PathNotChild,
 
1026
            urlutils.file_relpath, "file:///A:/b", "file:///A:/")
 
1027
        self.assertRaises(PathNotChild,
 
1028
            urlutils.file_relpath, "file:///A:/b/c", "file:///A:/b")
 
1029
 
 
1030
 
 
1031
class QuoteTests(TestCase):
 
1032
 
 
1033
    def test_quote(self):
 
1034
        self.assertEqual('abc%20def', urlutils.quote('abc def'))
 
1035
        self.assertEqual('abc%2Fdef', urlutils.quote('abc/def', safe=''))
 
1036
        self.assertEqual('abc/def', urlutils.quote('abc/def', safe='/'))
 
1037
 
 
1038
    def test_quote_tildes(self):
 
1039
        self.assertEqual('%7Efoo', urlutils.quote('~foo'))
 
1040
        self.assertEqual('~foo', urlutils.quote('~foo', safe='/~'))
 
1041
 
 
1042
    def test_unquote(self):
 
1043
        self.assertEqual('%', urlutils.unquote('%25'))
 
1044
        self.assertEqual('\xc3\xa5', urlutils.unquote('%C3%A5'))
 
1045
        self.assertEqual(u"\xe5", urlutils.unquote(u'\xe5'))