/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 breezy/tests/test_urlutils.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_urlutils.py
19
19
import os
20
20
import sys
21
21
 
22
 
from .. import osutils, urlutils
 
22
from .. import osutils, urlutils, win32utils
23
23
from ..errors import (
24
24
    PathNotChild,
25
25
    )
34
34
        basename = urlutils.basename
35
35
        if sys.platform == 'win32':
36
36
            self.assertRaises(urlutils.InvalidURL, basename,
37
 
                              'file:///path/to/foo')
 
37
                    'file:///path/to/foo')
38
38
            self.assertEqual('foo', basename('file:///C|/foo'))
39
39
            self.assertEqual('foo', basename('file:///C:/foo'))
40
40
            self.assertEqual('', basename('file:///C:/'))
44
44
 
45
45
        self.assertEqual('foo', basename('http://host/path/to/foo'))
46
46
        self.assertEqual('foo', basename('http://host/path/to/foo/'))
47
 
        self.assertEqual(
48
 
            '', basename('http://host/path/to/foo/',
49
 
                         exclude_trailing_slash=False))
 
47
        self.assertEqual('',
 
48
            basename('http://host/path/to/foo/', exclude_trailing_slash=False))
50
49
        self.assertEqual('path', basename('http://host/path'))
51
50
        self.assertEqual('', basename('http://host/'))
52
51
        self.assertEqual('', basename('http://host'))
53
52
        self.assertEqual('path', basename('http:///nohost/path'))
54
53
 
55
 
        self.assertEqual('path', basename(
56
 
            'random+scheme://user:pass@ahost:port/path'))
57
 
        self.assertEqual('path', basename(
58
 
            'random+scheme://user:pass@ahost:port/path/'))
 
54
        self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path'))
 
55
        self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path/'))
59
56
        self.assertEqual('', basename('random+scheme://user:pass@ahost:port/'))
60
57
 
61
58
        # relative paths
62
59
        self.assertEqual('foo', basename('path/to/foo'))
63
60
        self.assertEqual('foo', basename('path/to/foo/'))
64
61
        self.assertEqual('', basename('path/to/foo/',
65
 
                                      exclude_trailing_slash=False))
 
62
            exclude_trailing_slash=False))
66
63
        self.assertEqual('foo', basename('path/../foo'))
67
64
        self.assertEqual('foo', basename('../path/foo'))
68
65
 
121
118
 
122
119
        # Unescape characters that don't need to be escaped
123
120
        eq('http://host/~bob%2525-._',
124
 
           normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
 
121
                normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
125
122
        eq('http://host/~bob%2525-._',
126
 
           normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
 
123
                normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
 
124
 
 
125
        # Normalize verifies URLs when they are not unicode
 
126
        # (indicating they did not come from the user)
 
127
        self.assertRaises(urlutils.InvalidURL, normalize_url,
 
128
                'http://host/\xb5')
 
129
        self.assertRaises(urlutils.InvalidURL, normalize_url, 'http://host/ ')
127
130
 
128
131
    def test_url_scheme_re(self):
129
132
        # Test paths that may be URLs
152
155
        test_one('file:///usr/bin', ('file', '/usr/bin'))
153
156
        test_one('file:///C:/Windows', ('file', '/C:/Windows'))
154
157
        test_one('file:///C|/Windows', ('file', '/C|/Windows'))
155
 
        test_one(u'readonly+sftp://host/path/\xe5',
156
 
                 ('readonly+sftp', u'host/path/\xe5'))
 
158
        test_one(u'readonly+sftp://host/path/\xe5', ('readonly+sftp', u'host/path/\xe5'))
157
159
 
158
160
        # Weird stuff
159
161
        # Can't have slashes or colons in the scheme
168
170
        dirname = urlutils.dirname
169
171
        if sys.platform == 'win32':
170
172
            self.assertRaises(urlutils.InvalidURL, dirname,
171
 
                              'file:///path/to/foo')
 
173
                'file:///path/to/foo')
172
174
            self.assertEqual('file:///C|/', dirname('file:///C|/foo'))
173
175
            self.assertEqual('file:///C|/', dirname('file:///C|/'))
174
176
        else:
175
177
            self.assertEqual('file:///', dirname('file:///foo'))
176
178
            self.assertEqual('file:///', dirname('file:///'))
177
179
 
178
 
        self.assertEqual('http://host/path/to',
179
 
                         dirname('http://host/path/to/foo'))
180
 
        self.assertEqual('http://host/path/to',
181
 
                         dirname('http://host/path/to/foo/'))
 
180
        self.assertEqual('http://host/path/to', dirname('http://host/path/to/foo'))
 
181
        self.assertEqual('http://host/path/to', dirname('http://host/path/to/foo/'))
182
182
        self.assertEqual('http://host/path/to/foo',
183
 
                         dirname('http://host/path/to/foo/',
184
 
                                 exclude_trailing_slash=False))
 
183
            dirname('http://host/path/to/foo/', exclude_trailing_slash=False))
185
184
        self.assertEqual('http://host/', dirname('http://host/path'))
186
185
        self.assertEqual('http://host/', dirname('http://host/'))
187
186
        self.assertEqual('http://host', dirname('http://host'))
188
187
        self.assertEqual('http:///nohost', dirname('http:///nohost/path'))
189
188
 
190
189
        self.assertEqual('random+scheme://user:pass@ahost:port/',
191
 
                         dirname('random+scheme://user:pass@ahost:port/path'))
192
 
        self.assertEqual('random+scheme://user:pass@ahost:port/',
193
 
                         dirname('random+scheme://user:pass@ahost:port/path/'))
194
 
        self.assertEqual('random+scheme://user:pass@ahost:port/',
195
 
                         dirname('random+scheme://user:pass@ahost:port/'))
 
190
            dirname('random+scheme://user:pass@ahost:port/path'))
 
191
        self.assertEqual('random+scheme://user:pass@ahost:port/',
 
192
            dirname('random+scheme://user:pass@ahost:port/path/'))
 
193
        self.assertEqual('random+scheme://user:pass@ahost:port/',
 
194
            dirname('random+scheme://user:pass@ahost:port/'))
196
195
 
197
196
        # relative paths
198
197
        self.assertEqual('path/to', dirname('path/to/foo'))
199
198
        self.assertEqual('path/to', dirname('path/to/foo/'))
200
199
        self.assertEqual('path/to/foo',
201
 
                         dirname('path/to/foo/', exclude_trailing_slash=False))
 
200
            dirname('path/to/foo/', exclude_trailing_slash=False))
202
201
        self.assertEqual('path/..', dirname('path/../foo'))
203
202
        self.assertEqual('../path', dirname('../path/foo'))
204
 
 
 
203
    
205
204
    def test_is_url(self):
206
205
        self.assertTrue(urlutils.is_url('http://foo/bar'))
207
206
        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))
222
221
            self.assertEqual(expected, joined)
223
222
 
224
223
        # Test relative path joining
225
 
        test('foo', 'foo')  # relative fragment with nothing is preserved.
 
224
        test('foo', 'foo') # relative fragment with nothing is preserved.
226
225
        test('foo/bar', 'foo', 'bar')
227
226
        test('http://foo/bar', 'http://foo', 'bar')
228
227
        test('http://foo/bar', 'http://foo', '.', 'bar')
234
233
        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')
235
234
 
236
235
        # Absolute paths
237
 
        test('http://foo', 'http://foo')  # abs url with nothing is preserved.
 
236
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
238
237
        test('http://bar', 'http://foo', 'http://bar')
239
238
        test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')
240
239
        test('file:///bar', 'foo', 'file:///bar')
255
254
        # Cannot go above root
256
255
        # Implicitly at root:
257
256
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
258
 
                          'http://foo', '../baz')
 
257
                'http://foo', '../baz')
259
258
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
260
 
                          'http://foo', '/..')
 
259
                'http://foo', '/..')
261
260
        # Joining from a path explicitly under the root.
262
261
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
263
 
                          'http://foo/a', '../../b')
 
262
                'http://foo/a', '../../b')
264
263
 
265
264
    def test_joinpath(self):
266
265
        def test(expected, *args):
292
291
        # Invalid joinings
293
292
        # Cannot go above root
294
293
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
295
 
                          '../baz')
296
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
297
 
                          '..')
298
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
299
 
                          '/..')
 
294
                '../baz')
 
295
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
 
296
                '..')
 
297
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
 
298
                '/..')
300
299
 
301
300
    def test_join_segment_parameters_raw(self):
302
301
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
303
 
        self.assertEqual("/somedir/path",
304
 
                         join_segment_parameters_raw("/somedir/path"))
305
 
        self.assertEqual("/somedir/path,rawdata",
306
 
                         join_segment_parameters_raw(
307
 
                             "/somedir/path", "rawdata"))
 
302
        self.assertEqual("/somedir/path", 
 
303
            join_segment_parameters_raw("/somedir/path"))
 
304
        self.assertEqual("/somedir/path,rawdata", 
 
305
            join_segment_parameters_raw("/somedir/path", "rawdata"))
308
306
        self.assertRaises(urlutils.InvalidURLJoin,
309
 
                          join_segment_parameters_raw, "/somedir/path",
310
 
                          "rawdata1,rawdata2,rawdata3")
 
307
            join_segment_parameters_raw, "/somedir/path",
 
308
                "rawdata1,rawdata2,rawdata3")
311
309
        self.assertEqual("/somedir/path,bla,bar",
312
 
                         join_segment_parameters_raw(
313
 
                             "/somedir/path", "bla", "bar"))
314
 
        self.assertEqual(
315
 
            "/somedir,exist=some/path,bla,bar",
 
310
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
 
311
        self.assertEqual("/somedir,exist=some/path,bla,bar",
316
312
            join_segment_parameters_raw("/somedir,exist=some/path",
317
 
                                        "bla", "bar"))
318
 
        self.assertRaises(TypeError, join_segment_parameters_raw,
319
 
                          "/somepath", 42)
 
313
                "bla", "bar"))
 
314
        self.assertRaises(TypeError, join_segment_parameters_raw, 
 
315
            "/somepath", 42)
320
316
 
321
317
    def test_join_segment_parameters(self):
322
318
        join_segment_parameters = urlutils.join_segment_parameters
323
 
        self.assertEqual("/somedir/path",
324
 
                         join_segment_parameters("/somedir/path", {}))
325
 
        self.assertEqual(
326
 
            "/somedir/path,key1=val1",
 
319
        self.assertEqual("/somedir/path", 
 
320
            join_segment_parameters("/somedir/path", {}))
 
321
        self.assertEqual("/somedir/path,key1=val1", 
327
322
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
328
323
        self.assertRaises(urlutils.InvalidURLJoin,
329
 
                          join_segment_parameters, "/somedir/path",
330
 
                          {"branch": "brr,brr,brr"})
331
 
        self.assertRaises(
332
 
            urlutils.InvalidURLJoin,
 
324
            join_segment_parameters, "/somedir/path",
 
325
            {"branch": "brr,brr,brr"})
 
326
        self.assertRaises(urlutils.InvalidURLJoin,
333
327
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
334
328
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
335
 
                         join_segment_parameters("/somedir/path", {
336
 
                             "key1": "val1", "key2": "val2"}))
 
329
            join_segment_parameters("/somedir/path", {
 
330
                "key1": "val1", "key2": "val2"}))
337
331
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
338
 
                         join_segment_parameters("/somedir/path,key1=val1", {
339
 
                             "key2": "val2"}))
 
332
            join_segment_parameters("/somedir/path,key1=val1", {
 
333
                "key2": "val2"}))
340
334
        self.assertEqual("/somedir/path,key1=val2",
341
 
                         join_segment_parameters("/somedir/path,key1=val1", {
342
 
                             "key1": "val2"}))
 
335
            join_segment_parameters("/somedir/path,key1=val1", {
 
336
                "key1": "val2"}))
343
337
        self.assertEqual("/somedir,exist=some/path,key1=val1",
344
 
                         join_segment_parameters("/somedir,exist=some/path",
345
 
                                                 {"key1": "val1"}))
346
 
        self.assertEqual(
347
 
            "/,key1=val1,key2=val2",
 
338
            join_segment_parameters("/somedir,exist=some/path",
 
339
                {"key1": "val1"}))
 
340
        self.assertEqual("/,key1=val1,key2=val2",
348
341
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
349
342
        self.assertRaises(TypeError,
350
 
                          join_segment_parameters, "/,key1=val1", {"foo": 42})
 
343
            join_segment_parameters, "/,key1=val1", {"foo": 42})
351
344
 
352
345
    def test_function_type(self):
353
346
        if sys.platform == 'win32':
354
347
            self.assertEqual(urlutils._win32_local_path_to_url,
355
 
                             urlutils.local_path_to_url)
 
348
                urlutils.local_path_to_url)
356
349
            self.assertEqual(urlutils._win32_local_path_from_url,
357
 
                             urlutils.local_path_from_url)
 
350
                urlutils.local_path_from_url)
358
351
        else:
359
352
            self.assertEqual(urlutils._posix_local_path_to_url,
360
 
                             urlutils.local_path_to_url)
 
353
                urlutils.local_path_to_url)
361
354
            self.assertEqual(urlutils._posix_local_path_from_url,
362
 
                             urlutils.local_path_from_url)
 
355
                urlutils.local_path_from_url)
363
356
 
364
357
    def test_posix_local_path_to_url(self):
365
358
        to_url = urlutils._posix_local_path_to_url
366
359
        self.assertEqual('file:///path/to/foo',
367
 
                         to_url('/path/to/foo'))
 
360
            to_url('/path/to/foo'))
368
361
 
369
362
        self.assertEqual('file:///path/to/foo%2Cbar',
370
 
                         to_url('/path/to/foo,bar'))
 
363
            to_url('/path/to/foo,bar'))
371
364
 
372
365
        try:
373
366
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
375
368
            raise TestSkipped("local encoding cannot handle unicode")
376
369
 
377
370
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
378
 
        self.assertTrue(isinstance(result, str))
 
371
        self.assertFalse(isinstance(result, unicode))
379
372
 
380
373
    def test_posix_local_path_from_url(self):
381
374
        from_url = urlutils._posix_local_path_from_url
382
375
        self.assertEqual('/path/to/foo',
383
 
                         from_url('file:///path/to/foo'))
 
376
            from_url('file:///path/to/foo'))
384
377
        self.assertEqual('/path/to/foo',
385
 
                         from_url('file:///path/to/foo,branch=foo'))
386
 
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
387
 
                         from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
388
 
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
389
 
                         from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
390
 
        self.assertEqual(
391
 
            u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
378
            from_url('file:///path/to/foo,branch=foo'))
 
379
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
380
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
 
381
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
382
            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
 
383
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
392
384
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
393
385
 
394
386
        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
399
391
    def test_win32_local_path_to_url(self):
400
392
        to_url = urlutils._win32_local_path_to_url
401
393
        self.assertEqual('file:///C:/path/to/foo',
402
 
                         to_url('C:/path/to/foo'))
 
394
            to_url('C:/path/to/foo'))
403
395
        # BOGUS: on win32, ntpath.abspath will strip trailing
404
396
        #       whitespace, so this will always fail
405
397
        #       Though under linux, it fakes abspath support
407
399
        # self.assertEqual('file:///C:/path/to/foo%20',
408
400
        #     to_url('C:/path/to/foo '))
409
401
        self.assertEqual('file:///C:/path/to/f%20oo',
410
 
                         to_url('C:/path/to/f oo'))
 
402
            to_url('C:/path/to/f oo'))
411
403
 
412
404
        self.assertEqual('file:///', to_url('/'))
413
405
 
414
406
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
415
 
                         to_url('C:/path/to/foo,bar'))
 
407
            to_url('C:/path/to/foo,bar'))
416
408
        try:
417
409
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
418
410
        except UnicodeError:
419
411
            raise TestSkipped("local encoding cannot handle unicode")
420
412
 
421
 
        self.assertEqual(
422
 
            'file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
423
 
        self.assertIsInstance(result, str)
 
413
        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
414
        self.assertFalse(isinstance(result, unicode))
424
415
 
425
416
    def test_win32_unc_path_to_url(self):
426
417
        self.requireFeature(features.win32_feature)
427
418
        to_url = urlutils._win32_local_path_to_url
428
419
        self.assertEqual('file://HOST/path',
429
 
                         to_url(r'\\HOST\path'))
 
420
            to_url(r'\\HOST\path'))
430
421
        self.assertEqual('file://HOST/path',
431
 
                         to_url('//HOST/path'))
 
422
            to_url('//HOST/path'))
432
423
 
433
424
        try:
434
425
            result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')
435
426
        except UnicodeError:
436
427
            raise TestSkipped("local encoding cannot handle unicode")
437
428
 
438
 
        self.assertEqual(
439
 
            'file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
440
 
        self.assertFalse(isinstance(result, str))
 
429
        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
430
        self.assertFalse(isinstance(result, unicode))
441
431
 
442
432
    def test_win32_local_path_from_url(self):
443
433
        from_url = urlutils._win32_local_path_from_url
444
434
        self.assertEqual('C:/path/to/foo',
445
 
                         from_url('file:///C|/path/to/foo'))
446
 
        self.assertEqual(
447
 
            u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
 
435
            from_url('file:///C|/path/to/foo'))
 
436
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
448
437
            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
449
 
        self.assertEqual(
450
 
            u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
 
438
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
451
439
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
452
440
        self.assertEqual('/', from_url('file:///'))
453
441
        self.assertEqual('C:/path/to/foo',
454
 
                         from_url('file:///C|/path/to/foo,branch=foo'))
 
442
            from_url('file:///C|/path/to/foo,branch=foo'))
455
443
 
456
444
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///C:')
457
445
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///c')
463
451
        from_url = urlutils._win32_local_path_from_url
464
452
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
465
453
        self.assertEqual('//HOST/path',
466
 
                         from_url('file://HOST/path,branch=foo'))
 
454
            from_url('file://HOST/path,branch=foo'))
467
455
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
468
456
        # we want to use only 2 slashes
469
457
        # Firefox understand only 5 slashes in URL, but it's ugly
470
458
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:////HOST/path')
471
459
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://///HOST/path')
472
 
        self.assertRaises(urlutils.InvalidURL, from_url,
473
 
                          'file://////HOST/path')
 
460
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://////HOST/path')
474
461
        # check for file://C:/ instead of file:///C:/
475
462
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://C:/path')
476
463
 
477
464
    def test_win32_extract_drive_letter(self):
478
465
        extract = urlutils._win32_extract_drive_letter
479
466
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
480
 
        self.assertEqual(('file:///d|', '/path'),
481
 
                         extract('file://', '/d|/path'))
 
467
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
482
468
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/path')
483
469
        # Root drives without slash treated as invalid, see bug #841322
484
470
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
491
477
        # Test breezy.urlutils.split()
492
478
        split = urlutils.split
493
479
        if sys.platform == 'win32':
494
 
            self.assertRaises(urlutils.InvalidURL, split,
495
 
                              'file:///path/to/foo')
 
480
            self.assertRaises(urlutils.InvalidURL, split, 'file:///path/to/foo')
496
481
            self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))
497
482
            self.assertEqual(('file:///C:/', ''), split('file:///C:/'))
498
483
        else:
499
484
            self.assertEqual(('file:///', 'foo'), split('file:///foo'))
500
485
            self.assertEqual(('file:///', ''), split('file:///'))
501
486
 
502
 
        self.assertEqual(('http://host/path/to', 'foo'),
503
 
                         split('http://host/path/to/foo'))
504
 
        self.assertEqual(('http://host/path/to', 'foo'),
505
 
                         split('http://host/path/to/foo/'))
506
 
        self.assertEqual(
507
 
            ('http://host/path/to/foo', ''),
 
487
        self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo'))
 
488
        self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo/'))
 
489
        self.assertEqual(('http://host/path/to/foo', ''),
508
490
            split('http://host/path/to/foo/', exclude_trailing_slash=False))
509
491
        self.assertEqual(('http://host/', 'path'), split('http://host/path'))
510
492
        self.assertEqual(('http://host/', ''), split('http://host/'))
511
493
        self.assertEqual(('http://host', ''), split('http://host'))
512
 
        self.assertEqual(('http:///nohost', 'path'),
513
 
                         split('http:///nohost/path'))
 
494
        self.assertEqual(('http:///nohost', 'path'), split('http:///nohost/path'))
514
495
 
515
496
        self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
516
 
                         split('random+scheme://user:pass@ahost:port/path'))
 
497
            split('random+scheme://user:pass@ahost:port/path'))
517
498
        self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
518
 
                         split('random+scheme://user:pass@ahost:port/path/'))
 
499
            split('random+scheme://user:pass@ahost:port/path/'))
519
500
        self.assertEqual(('random+scheme://user:pass@ahost:port/', ''),
520
 
                         split('random+scheme://user:pass@ahost:port/'))
 
501
            split('random+scheme://user:pass@ahost:port/'))
521
502
 
522
503
        # relative paths
523
504
        self.assertEqual(('path/to', 'foo'), split('path/to/foo'))
524
505
        self.assertEqual(('path/to', 'foo'), split('path/to/foo/'))
525
506
        self.assertEqual(('path/to/foo', ''),
526
 
                         split('path/to/foo/', exclude_trailing_slash=False))
 
507
            split('path/to/foo/', exclude_trailing_slash=False))
527
508
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
528
509
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
529
510
 
530
 
    def test_strip_segment_parameters(self):
531
 
        strip_segment_parameters = urlutils.strip_segment_parameters
532
 
        # Check relative references with absolute paths
533
 
        self.assertEqual("/some/path",
534
 
                         strip_segment_parameters("/some/path"))
535
 
        self.assertEqual("/some/path",
536
 
                         strip_segment_parameters("/some/path,tip"))
537
 
        self.assertEqual("/some,dir/path",
538
 
                         strip_segment_parameters("/some,dir/path,tip"))
539
 
        self.assertEqual(
540
 
            "/somedir/path",
541
 
            strip_segment_parameters("/somedir/path,heads%2Ftip"))
542
 
        self.assertEqual(
543
 
            "/somedir/path",
544
 
            strip_segment_parameters("/somedir/path,heads%2Ftip,bar"))
545
 
        # Check relative references with relative paths
546
 
        self.assertEqual("", strip_segment_parameters(",key1=val1"))
547
 
        self.assertEqual("foo/", strip_segment_parameters("foo/,key1=val1"))
548
 
        self.assertEqual("foo", strip_segment_parameters("foo,key1=val1"))
549
 
        self.assertEqual(
550
 
            "foo/base,la=bla/other/elements",
551
 
            strip_segment_parameters("foo/base,la=bla/other/elements"))
552
 
        self.assertEqual(
553
 
            "foo/base,la=bla/other/elements",
554
 
            strip_segment_parameters("foo/base,la=bla/other/elements,a=b"))
555
 
        # TODO: Check full URLs as well as relative references
556
 
 
557
511
    def test_split_segment_parameters_raw(self):
558
512
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
559
513
        # Check relative references with absolute paths
560
514
        self.assertEqual(("/some/path", []),
561
 
                         split_segment_parameters_raw("/some/path"))
 
515
            split_segment_parameters_raw("/some/path"))
562
516
        self.assertEqual(("/some/path", ["tip"]),
563
 
                         split_segment_parameters_raw("/some/path,tip"))
 
517
            split_segment_parameters_raw("/some/path,tip"))
564
518
        self.assertEqual(("/some,dir/path", ["tip"]),
565
 
                         split_segment_parameters_raw("/some,dir/path,tip"))
566
 
        self.assertEqual(
567
 
            ("/somedir/path", ["heads%2Ftip"]),
 
519
            split_segment_parameters_raw("/some,dir/path,tip"))
 
520
        self.assertEqual(("/somedir/path", ["heads%2Ftip"]),
568
521
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
569
 
        self.assertEqual(
570
 
            ("/somedir/path", ["heads%2Ftip", "bar"]),
 
522
        self.assertEqual(("/somedir/path", ["heads%2Ftip", "bar"]),
571
523
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
572
524
        # Check relative references with relative paths
573
525
        self.assertEqual(("", ["key1=val1"]),
574
 
                         split_segment_parameters_raw(",key1=val1"))
 
526
            split_segment_parameters_raw(",key1=val1"))
575
527
        self.assertEqual(("foo/", ["key1=val1"]),
576
 
                         split_segment_parameters_raw("foo/,key1=val1"))
 
528
            split_segment_parameters_raw("foo/,key1=val1"))
577
529
        self.assertEqual(("foo", ["key1=val1"]),
578
 
                         split_segment_parameters_raw("foo,key1=val1"))
579
 
        self.assertEqual(
580
 
            ("foo/base,la=bla/other/elements", []),
 
530
            split_segment_parameters_raw("foo,key1=val1"))
 
531
        self.assertEqual(("foo/base,la=bla/other/elements", []),
581
532
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
582
 
        self.assertEqual(
583
 
            ("foo/base,la=bla/other/elements", ["a=b"]),
 
533
        self.assertEqual(("foo/base,la=bla/other/elements", ["a=b"]),
584
534
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
585
535
        # TODO: Check full URLs as well as relative references
586
536
 
588
538
        split_segment_parameters = urlutils.split_segment_parameters
589
539
        # Check relative references with absolute paths
590
540
        self.assertEqual(("/some/path", {}),
591
 
                         split_segment_parameters("/some/path"))
 
541
            split_segment_parameters("/some/path"))
592
542
        self.assertEqual(("/some/path", {"branch": "tip"}),
593
 
                         split_segment_parameters("/some/path,branch=tip"))
 
543
            split_segment_parameters("/some/path,branch=tip"))
594
544
        self.assertEqual(("/some,dir/path", {"branch": "tip"}),
595
 
                         split_segment_parameters("/some,dir/path,branch=tip"))
596
 
        self.assertEqual(
597
 
            ("/somedir/path", {"ref": "heads%2Ftip"}),
 
545
            split_segment_parameters("/some,dir/path,branch=tip"))
 
546
        self.assertEqual(("/somedir/path", {"ref": "heads%2Ftip"}),
598
547
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
599
548
        self.assertEqual(("/somedir/path",
600
 
                          {"ref": "heads%2Ftip", "key1": "val1"}),
601
 
                         split_segment_parameters(
602
 
            "/somedir/path,ref=heads%2Ftip,key1=val1"))
603
 
        self.assertEqual(
604
 
            ("/somedir/path", {"ref": "heads%2F=tip"}),
 
549
            {"ref": "heads%2Ftip", "key1": "val1"}),
 
550
            split_segment_parameters(
 
551
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
 
552
        self.assertEqual(("/somedir/path", {"ref": "heads%2F=tip"}),
605
553
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
606
554
        # Check relative references with relative paths
607
555
        self.assertEqual(("", {"key1": "val1"}),
608
 
                         split_segment_parameters(",key1=val1"))
 
556
            split_segment_parameters(",key1=val1"))
609
557
        self.assertEqual(("foo/", {"key1": "val1"}),
610
 
                         split_segment_parameters("foo/,key1=val1"))
611
 
        self.assertEqual(
612
 
            ("foo/base,key1=val1/other/elements", {}),
 
558
            split_segment_parameters("foo/,key1=val1"))
 
559
        self.assertEqual(("foo/base,key1=val1/other/elements", {}),
613
560
            split_segment_parameters("foo/base,key1=val1/other/elements"))
614
561
        self.assertEqual(("foo/base,key1=val1/other/elements",
615
 
                          {"key2": "val2"}), split_segment_parameters(
616
 
            "foo/base,key1=val1/other/elements,key2=val2"))
617
 
        self.assertRaises(
618
 
            urlutils.InvalidURL, split_segment_parameters,
619
 
            "foo/base,key1")
 
562
            {"key2": "val2"}), split_segment_parameters(
 
563
                "foo/base,key1=val1/other/elements,key2=val2"))
620
564
        # TODO: Check full URLs as well as relative references
621
565
 
622
566
    def test_win32_strip_local_trailing_slash(self):
650
594
        self.assertEqual('file://', sts('file://'))
651
595
 
652
596
        self.assertEqual('random+scheme://user:pass@ahost:port/path',
653
 
                         sts('random+scheme://user:pass@ahost:port/path'))
 
597
            sts('random+scheme://user:pass@ahost:port/path'))
654
598
        self.assertEqual('random+scheme://user:pass@ahost:port/path',
655
 
                         sts('random+scheme://user:pass@ahost:port/path/'))
 
599
            sts('random+scheme://user:pass@ahost:port/path/'))
656
600
        self.assertEqual('random+scheme://user:pass@ahost:port/',
657
 
                         sts('random+scheme://user:pass@ahost:port/'))
 
601
            sts('random+scheme://user:pass@ahost:port/'))
658
602
 
659
603
        # Make sure relative paths work too
660
604
        self.assertEqual('path/to/foo', sts('path/to/foo'))
666
610
        # Test that URLs are converted to nice unicode strings for display
667
611
        def test(expected, url, encoding='utf-8'):
668
612
            disp_url = urlutils.unescape_for_display(url, encoding=encoding)
669
 
            self.assertIsInstance(disp_url, str)
 
613
            self.assertIsInstance(disp_url, unicode)
670
614
            self.assertEqual(expected, disp_url)
671
615
 
672
616
        test('http://foo', 'http://foo')
706
650
    def test_escape(self):
707
651
        self.assertEqual('%25', urlutils.escape('%'))
708
652
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
709
 
        self.assertIsInstance(urlutils.escape(u'\xe5'), str)
 
653
        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
710
654
 
711
655
    def test_escape_tildes(self):
712
656
        self.assertEqual('~foo', urlutils.escape('~foo'))
715
659
        self.assertEqual('%', urlutils.unescape('%25'))
716
660
        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
717
661
 
718
 
        self.assertRaises((TypeError, urlutils.InvalidURL),
719
 
                          urlutils.unescape, b'\xe5')
720
 
        self.assertEqual('\xe5', urlutils.unescape('%C3%A5'))
 
662
        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, u'\xe5')
 
663
        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, '\xe5')
 
664
        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, '%E5')
721
665
 
722
666
    def test_escape_unescape(self):
723
667
        self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
730
674
 
731
675
        test('a', 'http://host/', 'http://host/a')
732
676
        test('http://entirely/different', 'sftp://host/branch',
733
 
             'http://entirely/different')
 
677
                    'http://entirely/different')
734
678
        test('../person/feature', 'http://host/branch/mainline',
735
 
             'http://host/branch/person/feature')
 
679
                    'http://host/branch/person/feature')
736
680
        test('..', 'http://host/branch', 'http://host/')
737
 
        test('http://host2/branch', 'http://host1/branch',
738
 
             'http://host2/branch')
 
681
        test('http://host2/branch', 'http://host1/branch', 'http://host2/branch')
739
682
        test('.', 'http://host1/branch', 'http://host1/branch')
740
683
        test('../../../branch/2b', 'file:///home/jelmer/foo/bar/2b',
741
 
             'file:///home/jelmer/branch/2b')
 
684
                    'file:///home/jelmer/branch/2b')
742
685
        test('../../branch/2b', 'sftp://host/home/jelmer/bar/2b',
743
 
             'sftp://host/home/jelmer/branch/2b')
 
686
                    'sftp://host/home/jelmer/branch/2b')
744
687
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
745
 
             'http://host/home/jelmer/branch/feature/%2b')
 
688
                    'http://host/home/jelmer/branch/feature/%2b')
746
689
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
747
 
             'http://host/home/jelmer/branch/feature/2b')
 
690
                    'http://host/home/jelmer/branch/feature/2b')
748
691
        # relative_url should preserve a trailing slash
749
692
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
750
 
             'http://host/home/jelmer/branch/feature/2b/')
 
693
                    'http://host/home/jelmer/branch/feature/2b/')
751
694
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b',
752
 
             'http://host/home/jelmer/branch/feature/2b/')
 
695
                    'http://host/home/jelmer/branch/feature/2b/')
753
696
 
754
697
        # TODO: treat http://host as http://host/
755
698
        #       relative_url is typically called from a branch.base or
756
699
        #       transport.base which always ends with a /
757
 
        # test('a', 'http://host', 'http://host/a')
 
700
        #test('a', 'http://host', 'http://host/a')
758
701
        test('http://host/a', 'http://host', 'http://host/a')
759
 
        # test('.', 'http://host', 'http://host/')
 
702
        #test('.', 'http://host', 'http://host/')
760
703
        test('http://host/', 'http://host', 'http://host/')
761
 
        # test('.', 'http://host/', 'http://host')
 
704
        #test('.', 'http://host/', 'http://host')
762
705
        test('http://host', 'http://host/', 'http://host')
763
706
 
764
707
        # On Windows file:///C:/path/to and file:///D:/other/path
766
709
        if sys.platform == 'win32':
767
710
            # on the same drive
768
711
            test('../../other/path',
769
 
                 'file:///C:/path/to', 'file:///C:/other/path')
770
 
            # ~next two tests is failed, i.e. urlutils.relative_url expects
771
 
            # ~to see normalized file URLs?
772
 
            # ~test('../../other/path',
773
 
            # ~    'file:///C:/path/to', 'file:///c:/other/path')
774
 
            # ~test('../../other/path',
775
 
            # ~    'file:///C:/path/to', 'file:///C|/other/path')
 
712
                'file:///C:/path/to', 'file:///C:/other/path')
 
713
            #~next two tests is failed, i.e. urlutils.relative_url expects
 
714
            #~to see normalized file URLs?
 
715
            #~test('../../other/path',
 
716
            #~    'file:///C:/path/to', 'file:///c:/other/path')
 
717
            #~test('../../other/path',
 
718
            #~    'file:///C:/path/to', 'file:///C|/other/path')
776
719
 
777
720
            # check UNC paths too
778
721
            test('../../other/path',
779
 
                 'file://HOST/base/path/to', 'file://HOST/base/other/path')
 
722
                'file://HOST/base/path/to', 'file://HOST/base/other/path')
780
723
            # on different drives
781
724
            test('file:///D:/other/path',
782
 
                 'file:///C:/path/to', 'file:///D:/other/path')
 
725
                'file:///C:/path/to', 'file:///D:/other/path')
783
726
            # TODO: strictly saying in UNC path //HOST/base is full analog
784
727
            # of drive letter for hard disk, and this situation is also
785
728
            # should be exception from rules. [bialix 20071221]
861
804
 
862
805
    def test_rebase_success(self):
863
806
        self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',
864
 
                                                       'http://baz/qux'))
865
 
        self.assertEqual(
866
 
            'qux/bar',
867
 
            urlutils.rebase_url('bar', 'http://baz/qux', 'http://baz/'))
868
 
        self.assertEqual(
869
 
            '.', urlutils.rebase_url('foo', 'http://bar/', 'http://bar/foo/'))
870
 
        self.assertEqual(
871
 
            'qux/bar',
872
 
            urlutils.rebase_url('../bar', 'http://baz/qux/foo', 'http://baz/'))
 
807
                         'http://baz/qux'))
 
808
        self.assertEqual('qux/bar', urlutils.rebase_url('bar',
 
809
                         'http://baz/qux', 'http://baz/'))
 
810
        self.assertEqual('.', urlutils.rebase_url('foo',
 
811
                         'http://bar/', 'http://bar/foo/'))
 
812
        self.assertEqual('qux/bar', urlutils.rebase_url('../bar',
 
813
                         'http://baz/qux/foo', 'http://baz/'))
873
814
 
874
815
    def test_determine_relative_path(self):
875
816
        self.assertEqual('../../baz/bar',
876
817
                         urlutils.determine_relative_path(
877
 
                             '/qux/quxx', '/baz/bar'))
 
818
                         '/qux/quxx', '/baz/bar'))
878
819
        self.assertEqual('..',
879
820
                         urlutils.determine_relative_path(
880
 
                             '/bar/baz', '/bar'))
 
821
                         '/bar/baz', '/bar'))
881
822
        self.assertEqual('baz',
882
823
                         urlutils.determine_relative_path(
883
 
                             '/bar', '/bar/baz'))
 
824
                         '/bar', '/bar/baz'))
884
825
        self.assertEqual('.', urlutils.determine_relative_path(
885
826
                         '/bar', '/bar'))
886
827
 
890
831
    def test_parse_simple(self):
891
832
        parsed = urlutils.parse_url('http://example.com:80/one')
892
833
        self.assertEqual(('http', None, None, 'example.com', 80, '/one'),
893
 
                         parsed)
 
834
            parsed)
894
835
 
895
836
    def test_ipv6(self):
896
837
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
897
838
        self.assertEqual(('http', None, None, '1:2:3::40', None, '/one'),
898
 
                         parsed)
 
839
            parsed)
899
840
 
900
841
    def test_ipv6_port(self):
901
842
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
902
843
        self.assertEqual(('http', None, None, '1:2:3::40', 80, '/one'),
903
 
                         parsed)
 
844
            parsed)
904
845
 
905
846
 
906
847
class TestURL(TestCase):
983
924
        self.assertIsNot(url, url3)
984
925
        self.assertEqual(url, url3)
985
926
 
986
 
    def test_parse_empty_port(self):
987
 
        parsed = urlutils.URL.from_string('http://example.com:/one')
988
 
        self.assertEqual('http', parsed.scheme)
989
 
        self.assertIs(None, parsed.user)
990
 
        self.assertIs(None, parsed.password)
991
 
        self.assertEqual('example.com', parsed.host)
992
 
        self.assertIs(None, parsed.port)
993
 
        self.assertEqual('/one', parsed.path)
994
 
 
995
927
 
996
928
class TestFileRelpath(TestCase):
997
929
 
1000
932
 
1001
933
    def _with_posix_paths(self):
1002
934
        self.overrideAttr(urlutils, "local_path_from_url",
1003
 
                          urlutils._posix_local_path_from_url)
 
935
            urlutils._posix_local_path_from_url)
1004
936
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH", len("file:///"))
1005
937
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
1006
938
        self.overrideAttr(osutils, "abspath", osutils._posix_abspath)
1011
943
 
1012
944
    def _with_win32_paths(self):
1013
945
        self.overrideAttr(urlutils, "local_path_from_url",
1014
 
                          urlutils._win32_local_path_from_url)
 
946
            urlutils._win32_local_path_from_url)
1015
947
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH",
1016
 
                          urlutils.WIN32_MIN_ABS_FILEURL_LENGTH)
 
948
            urlutils.WIN32_MIN_ABS_FILEURL_LENGTH)
1017
949
        self.overrideAttr(osutils, "abspath", osutils._win32_abspath)
1018
950
        self.overrideAttr(osutils, "normpath", osutils._win32_normpath)
1019
951
        self.overrideAttr(osutils, "pathjoin", osutils._win32_pathjoin)
1023
955
    def test_same_url_posix(self):
1024
956
        self._with_posix_paths()
1025
957
        self.assertEqual("",
1026
 
                         urlutils.file_relpath("file:///a", "file:///a"))
1027
 
        self.assertEqual("",
1028
 
                         urlutils.file_relpath("file:///a", "file:///a/"))
1029
 
        self.assertEqual("",
1030
 
                         urlutils.file_relpath("file:///a/", "file:///a"))
 
958
            urlutils.file_relpath("file:///a", "file:///a"))
 
959
        self.assertEqual("",
 
960
            urlutils.file_relpath("file:///a", "file:///a/"))
 
961
        self.assertEqual("",
 
962
            urlutils.file_relpath("file:///a/", "file:///a"))
1031
963
 
1032
964
    def test_same_url_win32(self):
1033
965
        self._with_win32_paths()
1034
966
        self.assertEqual("",
1035
 
                         urlutils.file_relpath("file:///A:/", "file:///A:/"))
1036
 
        self.assertEqual("",
1037
 
                         urlutils.file_relpath("file:///A|/", "file:///A:/"))
1038
 
        self.assertEqual(
1039
 
            "", urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
1040
 
        self.assertEqual(
1041
 
            "", urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
1042
 
        self.assertEqual(
1043
 
            "", urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
 
967
            urlutils.file_relpath("file:///A:/", "file:///A:/"))
 
968
        self.assertEqual("",
 
969
            urlutils.file_relpath("file:///A|/", "file:///A:/"))
 
970
        self.assertEqual("",
 
971
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
 
972
        self.assertEqual("",
 
973
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
 
974
        self.assertEqual("",
 
975
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
1044
976
 
1045
977
    def test_child_posix(self):
1046
978
        self._with_posix_paths()
1047
 
        self.assertEqual(
1048
 
            "b", urlutils.file_relpath("file:///a", "file:///a/b"))
1049
 
        self.assertEqual(
1050
 
            "b", urlutils.file_relpath("file:///a/", "file:///a/b"))
1051
 
        self.assertEqual(
1052
 
            "b/c", urlutils.file_relpath("file:///a", "file:///a/b/c"))
 
979
        self.assertEqual("b",
 
980
            urlutils.file_relpath("file:///a", "file:///a/b"))
 
981
        self.assertEqual("b",
 
982
            urlutils.file_relpath("file:///a/", "file:///a/b"))
 
983
        self.assertEqual("b/c",
 
984
            urlutils.file_relpath("file:///a", "file:///a/b/c"))
1053
985
 
1054
986
    def test_child_win32(self):
1055
987
        self._with_win32_paths()
1056
 
        self.assertEqual(
1057
 
            "b", urlutils.file_relpath("file:///A:/", "file:///A:/b"))
1058
 
        self.assertEqual(
1059
 
            "b", urlutils.file_relpath("file:///A|/", "file:///A:/b"))
1060
 
        self.assertEqual(
1061
 
            "c", urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
1062
 
        self.assertEqual(
1063
 
            "c", urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
1064
 
        self.assertEqual(
1065
 
            "c/d", urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
 
988
        self.assertEqual("b",
 
989
            urlutils.file_relpath("file:///A:/", "file:///A:/b"))
 
990
        self.assertEqual("b",
 
991
            urlutils.file_relpath("file:///A|/", "file:///A:/b"))
 
992
        self.assertEqual("c",
 
993
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
 
994
        self.assertEqual("c",
 
995
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
 
996
        self.assertEqual("c/d",
 
997
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
1066
998
 
1067
999
    def test_sibling_posix(self):
1068
1000
        self._with_posix_paths()
1069
 
        self.assertRaises(
1070
 
            PathNotChild,
 
1001
        self.assertRaises(PathNotChild,
1071
1002
            urlutils.file_relpath, "file:///a/b", "file:///a/c")
1072
 
        self.assertRaises(
1073
 
            PathNotChild,
 
1003
        self.assertRaises(PathNotChild,
1074
1004
            urlutils.file_relpath, "file:///a/b/", "file:///a/c")
1075
 
        self.assertRaises(
1076
 
            PathNotChild,
 
1005
        self.assertRaises(PathNotChild,
1077
1006
            urlutils.file_relpath, "file:///a/b/", "file:///a/c/")
1078
1007
 
1079
1008
    def test_sibling_win32(self):
1080
1009
        self._with_win32_paths()
1081
 
        self.assertRaises(
1082
 
            PathNotChild,
 
1010
        self.assertRaises(PathNotChild,
1083
1011
            urlutils.file_relpath, "file:///A:/b", "file:///A:/c")
1084
 
        self.assertRaises(
1085
 
            PathNotChild,
 
1012
        self.assertRaises(PathNotChild,
1086
1013
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c")
1087
 
        self.assertRaises(
1088
 
            PathNotChild,
 
1014
        self.assertRaises(PathNotChild,
1089
1015
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c/")
1090
1016
 
1091
1017
    def test_parent_posix(self):
1092
1018
        self._with_posix_paths()
1093
1019
        self.assertRaises(PathNotChild,
1094
 
                          urlutils.file_relpath, "file:///a/b", "file:///a")
 
1020
            urlutils.file_relpath, "file:///a/b", "file:///a")
1095
1021
        self.assertRaises(PathNotChild,
1096
 
                          urlutils.file_relpath, "file:///a/b", "file:///a/")
 
1022
            urlutils.file_relpath, "file:///a/b", "file:///a/")
1097
1023
 
1098
1024
    def test_parent_win32(self):
1099
1025
        self._with_win32_paths()
1100
 
        self.assertRaises(
1101
 
            PathNotChild,
 
1026
        self.assertRaises(PathNotChild,
1102
1027
            urlutils.file_relpath, "file:///A:/b", "file:///A:/")
1103
 
        self.assertRaises(
1104
 
            PathNotChild,
 
1028
        self.assertRaises(PathNotChild,
1105
1029
            urlutils.file_relpath, "file:///A:/b/c", "file:///A:/b")
1106
1030
 
1107
1031
 
1113
1037
        self.assertEqual('abc/def', urlutils.quote('abc/def', safe='/'))
1114
1038
 
1115
1039
    def test_quote_tildes(self):
1116
 
        # Whether ~ is quoted by default depends on the python version
1117
 
        if sys.version_info[:2] >= (3, 7):
1118
 
            # https://docs.python.org/3/whatsnew/3.7.html#urllib-parse
1119
 
            self.assertEqual('~foo', urlutils.quote('~foo'))
1120
 
        else:
1121
 
            self.assertEqual('%7Efoo', urlutils.quote('~foo'))
 
1040
        self.assertEqual('%7Efoo', urlutils.quote('~foo'))
1122
1041
        self.assertEqual('~foo', urlutils.quote('~foo', safe='/~'))
1123
1042
 
1124
1043
    def test_unquote(self):
1125
1044
        self.assertEqual('%', urlutils.unquote('%25'))
1126
 
        self.assertEqual('\xe5', urlutils.unquote('%C3%A5'))
 
1045
        self.assertEqual('\xc3\xa5', urlutils.unquote('%C3%A5'))
1127
1046
        self.assertEqual(u"\xe5", urlutils.unquote(u'\xe5'))
1128
 
 
1129
 
    def test_unquote_to_bytes(self):
1130
 
        self.assertEqual(b'%', urlutils.unquote_to_bytes('%25'))
1131
 
        self.assertEqual(b'\xc3\xa5', urlutils.unquote_to_bytes('%C3%A5'))