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

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
brzlib/tests/test_urlutils.py
19
19
import os
20
20
import sys
21
21
 
22
 
from .. import osutils, urlutils
23
 
from ..errors import (
 
22
from brzlib import osutils, urlutils, win32utils
 
23
from brzlib.errors import (
 
24
    InvalidURL,
 
25
    InvalidURLJoin,
 
26
    InvalidRebaseURLs,
24
27
    PathNotChild,
25
28
    )
26
 
from . import features, TestCaseInTempDir, TestCase, TestSkipped
 
29
from brzlib.tests import features, TestCaseInTempDir, TestCase, TestSkipped
27
30
 
28
31
 
29
32
class TestUrlToPath(TestCase):
30
33
 
31
34
    def test_basename(self):
32
 
        # breezy.urlutils.basename
33
 
        # Test breezy.urlutils.split()
 
35
        # brzlib.urlutils.basename
 
36
        # Test brzlib.urlutils.split()
34
37
        basename = urlutils.basename
35
38
        if sys.platform == 'win32':
36
 
            self.assertRaises(urlutils.InvalidURL, basename,
37
 
                              'file:///path/to/foo')
 
39
            self.assertRaises(InvalidURL, basename, 'file:///path/to/foo')
38
40
            self.assertEqual('foo', basename('file:///C|/foo'))
39
41
            self.assertEqual('foo', basename('file:///C:/foo'))
40
42
            self.assertEqual('', basename('file:///C:/'))
44
46
 
45
47
        self.assertEqual('foo', basename('http://host/path/to/foo'))
46
48
        self.assertEqual('foo', basename('http://host/path/to/foo/'))
47
 
        self.assertEqual(
48
 
            '', basename('http://host/path/to/foo/',
49
 
                         exclude_trailing_slash=False))
 
49
        self.assertEqual('',
 
50
            basename('http://host/path/to/foo/', exclude_trailing_slash=False))
50
51
        self.assertEqual('path', basename('http://host/path'))
51
52
        self.assertEqual('', basename('http://host/'))
52
53
        self.assertEqual('', basename('http://host'))
53
54
        self.assertEqual('path', basename('http:///nohost/path'))
54
55
 
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/'))
 
56
        self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path'))
 
57
        self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path/'))
59
58
        self.assertEqual('', basename('random+scheme://user:pass@ahost:port/'))
60
59
 
61
60
        # relative paths
62
61
        self.assertEqual('foo', basename('path/to/foo'))
63
62
        self.assertEqual('foo', basename('path/to/foo/'))
64
63
        self.assertEqual('', basename('path/to/foo/',
65
 
                                      exclude_trailing_slash=False))
 
64
            exclude_trailing_slash=False))
66
65
        self.assertEqual('foo', basename('path/../foo'))
67
66
        self.assertEqual('foo', basename('../path/foo'))
68
67
 
121
120
 
122
121
        # Unescape characters that don't need to be escaped
123
122
        eq('http://host/~bob%2525-._',
124
 
           normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
 
123
                normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
125
124
        eq('http://host/~bob%2525-._',
126
 
           normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
 
125
                normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
 
126
 
 
127
        # Normalize verifies URLs when they are not unicode
 
128
        # (indicating they did not come from the user)
 
129
        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
 
130
        self.assertRaises(InvalidURL, normalize_url, 'http://host/ ')
127
131
 
128
132
    def test_url_scheme_re(self):
129
133
        # Test paths that may be URLs
152
156
        test_one('file:///usr/bin', ('file', '/usr/bin'))
153
157
        test_one('file:///C:/Windows', ('file', '/C:/Windows'))
154
158
        test_one('file:///C|/Windows', ('file', '/C|/Windows'))
155
 
        test_one(u'readonly+sftp://host/path/\xe5',
156
 
                 ('readonly+sftp', u'host/path/\xe5'))
 
159
        test_one(u'readonly+sftp://host/path/\xe5', ('readonly+sftp', u'host/path/\xe5'))
157
160
 
158
161
        # Weird stuff
159
162
        # Can't have slashes or colons in the scheme
164
167
        test_one('ab://foo', ('ab', 'foo'))
165
168
 
166
169
    def test_dirname(self):
167
 
        # Test breezy.urlutils.dirname()
 
170
        # Test brzlib.urlutils.dirname()
168
171
        dirname = urlutils.dirname
169
172
        if sys.platform == 'win32':
170
 
            self.assertRaises(urlutils.InvalidURL, dirname,
171
 
                              'file:///path/to/foo')
 
173
            self.assertRaises(InvalidURL, dirname, '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')
254
253
        # Invalid joinings
255
254
        # Cannot go above root
256
255
        # Implicitly at root:
257
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
258
 
                          'http://foo', '../baz')
259
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
260
 
                          'http://foo', '/..')
 
256
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
257
                'http://foo', '../baz')
 
258
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
259
                'http://foo', '/..')
261
260
        # Joining from a path explicitly under the root.
262
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
263
 
                          'http://foo/a', '../../b')
 
261
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
262
                'http://foo/a', '../../b')
264
263
 
265
264
    def test_joinpath(self):
266
265
        def test(expected, *args):
291
290
 
292
291
        # Invalid joinings
293
292
        # Cannot go above root
294
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
295
 
                          '../baz')
296
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
297
 
                          '..')
298
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
299
 
                          '/..')
 
293
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
 
294
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
 
295
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
300
296
 
301
297
    def test_join_segment_parameters_raw(self):
302
298
        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"))
308
 
        self.assertRaises(urlutils.InvalidURLJoin,
309
 
                          join_segment_parameters_raw, "/somedir/path",
310
 
                          "rawdata1,rawdata2,rawdata3")
 
299
        self.assertEqual("/somedir/path", 
 
300
            join_segment_parameters_raw("/somedir/path"))
 
301
        self.assertEqual("/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")
311
306
        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",
 
307
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
 
308
        self.assertEqual("/somedir,exist=some/path,bla,bar",
316
309
            join_segment_parameters_raw("/somedir,exist=some/path",
317
 
                                        "bla", "bar"))
318
 
        self.assertRaises(TypeError, join_segment_parameters_raw,
319
 
                          "/somepath", 42)
 
310
                "bla", "bar"))
 
311
        self.assertRaises(TypeError, join_segment_parameters_raw, 
 
312
            "/somepath", 42)
320
313
 
321
314
    def test_join_segment_parameters(self):
322
315
        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",
 
316
        self.assertEqual("/somedir/path", 
 
317
            join_segment_parameters("/somedir/path", {}))
 
318
        self.assertEqual("/somedir/path,key1=val1", 
327
319
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
328
 
        self.assertRaises(urlutils.InvalidURLJoin,
329
 
                          join_segment_parameters, "/somedir/path",
330
 
                          {"branch": "brr,brr,brr"})
331
 
        self.assertRaises(
332
 
            urlutils.InvalidURLJoin,
 
320
        self.assertRaises(InvalidURLJoin,
 
321
            join_segment_parameters, "/somedir/path",
 
322
            {"branch": "brr,brr,brr"})
 
323
        self.assertRaises(InvalidURLJoin,
333
324
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
334
325
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
335
 
                         join_segment_parameters("/somedir/path", {
336
 
                             "key1": "val1", "key2": "val2"}))
 
326
            join_segment_parameters("/somedir/path", {
 
327
                "key1": "val1", "key2": "val2"}))
337
328
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
338
 
                         join_segment_parameters("/somedir/path,key1=val1", {
339
 
                             "key2": "val2"}))
 
329
            join_segment_parameters("/somedir/path,key1=val1", {
 
330
                "key2": "val2"}))
340
331
        self.assertEqual("/somedir/path,key1=val2",
341
 
                         join_segment_parameters("/somedir/path,key1=val1", {
342
 
                             "key1": "val2"}))
 
332
            join_segment_parameters("/somedir/path,key1=val1", {
 
333
                "key1": "val2"}))
343
334
        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",
 
335
            join_segment_parameters("/somedir,exist=some/path",
 
336
                {"key1": "val1"}))
 
337
        self.assertEqual("/,key1=val1,key2=val2",
348
338
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
349
339
        self.assertRaises(TypeError,
350
 
                          join_segment_parameters, "/,key1=val1", {"foo": 42})
 
340
            join_segment_parameters, "/,key1=val1", {"foo": 42})
351
341
 
352
342
    def test_function_type(self):
353
343
        if sys.platform == 'win32':
354
344
            self.assertEqual(urlutils._win32_local_path_to_url,
355
 
                             urlutils.local_path_to_url)
 
345
                urlutils.local_path_to_url)
356
346
            self.assertEqual(urlutils._win32_local_path_from_url,
357
 
                             urlutils.local_path_from_url)
 
347
                urlutils.local_path_from_url)
358
348
        else:
359
349
            self.assertEqual(urlutils._posix_local_path_to_url,
360
 
                             urlutils.local_path_to_url)
 
350
                urlutils.local_path_to_url)
361
351
            self.assertEqual(urlutils._posix_local_path_from_url,
362
 
                             urlutils.local_path_from_url)
 
352
                urlutils.local_path_from_url)
363
353
 
364
354
    def test_posix_local_path_to_url(self):
365
355
        to_url = urlutils._posix_local_path_to_url
366
356
        self.assertEqual('file:///path/to/foo',
367
 
                         to_url('/path/to/foo'))
 
357
            to_url('/path/to/foo'))
368
358
 
369
359
        self.assertEqual('file:///path/to/foo%2Cbar',
370
 
                         to_url('/path/to/foo,bar'))
 
360
            to_url('/path/to/foo,bar'))
371
361
 
372
362
        try:
373
363
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
375
365
            raise TestSkipped("local encoding cannot handle unicode")
376
366
 
377
367
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
378
 
        self.assertTrue(isinstance(result, str))
 
368
        self.assertFalse(isinstance(result, unicode))
379
369
 
380
370
    def test_posix_local_path_from_url(self):
381
371
        from_url = urlutils._posix_local_path_from_url
382
372
        self.assertEqual('/path/to/foo',
383
 
                         from_url('file:///path/to/foo'))
 
373
            from_url('file:///path/to/foo'))
384
374
        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',
 
375
            from_url('file:///path/to/foo,branch=foo'))
 
376
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
377
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
 
378
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
379
            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
 
380
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
392
381
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
393
382
 
394
 
        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
 
383
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
395
384
        self.assertRaises(
396
 
            urlutils.InvalidURL, from_url,
 
385
            InvalidURL, from_url,
397
386
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
398
387
 
399
388
    def test_win32_local_path_to_url(self):
400
389
        to_url = urlutils._win32_local_path_to_url
401
390
        self.assertEqual('file:///C:/path/to/foo',
402
 
                         to_url('C:/path/to/foo'))
 
391
            to_url('C:/path/to/foo'))
403
392
        # BOGUS: on win32, ntpath.abspath will strip trailing
404
393
        #       whitespace, so this will always fail
405
394
        #       Though under linux, it fakes abspath support
407
396
        # self.assertEqual('file:///C:/path/to/foo%20',
408
397
        #     to_url('C:/path/to/foo '))
409
398
        self.assertEqual('file:///C:/path/to/f%20oo',
410
 
                         to_url('C:/path/to/f oo'))
 
399
            to_url('C:/path/to/f oo'))
411
400
 
412
401
        self.assertEqual('file:///', to_url('/'))
413
402
 
414
403
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
415
 
                         to_url('C:/path/to/foo,bar'))
 
404
            to_url('C:/path/to/foo,bar'))
416
405
        try:
417
406
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
418
407
        except UnicodeError:
419
408
            raise TestSkipped("local encoding cannot handle unicode")
420
409
 
421
 
        self.assertEqual(
422
 
            'file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
423
 
        self.assertIsInstance(result, str)
 
410
        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
411
        self.assertFalse(isinstance(result, unicode))
424
412
 
425
413
    def test_win32_unc_path_to_url(self):
426
414
        self.requireFeature(features.win32_feature)
427
415
        to_url = urlutils._win32_local_path_to_url
428
416
        self.assertEqual('file://HOST/path',
429
 
                         to_url(r'\\HOST\path'))
 
417
            to_url(r'\\HOST\path'))
430
418
        self.assertEqual('file://HOST/path',
431
 
                         to_url('//HOST/path'))
 
419
            to_url('//HOST/path'))
432
420
 
433
421
        try:
434
422
            result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')
435
423
        except UnicodeError:
436
424
            raise TestSkipped("local encoding cannot handle unicode")
437
425
 
438
 
        self.assertEqual(
439
 
            'file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
440
 
        self.assertFalse(isinstance(result, str))
 
426
        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
427
        self.assertFalse(isinstance(result, unicode))
441
428
 
442
429
    def test_win32_local_path_from_url(self):
443
430
        from_url = urlutils._win32_local_path_from_url
444
431
        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',
 
432
            from_url('file:///C|/path/to/foo'))
 
433
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
448
434
            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',
 
435
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
451
436
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
452
437
        self.assertEqual('/', from_url('file:///'))
453
438
        self.assertEqual('C:/path/to/foo',
454
 
                         from_url('file:///C|/path/to/foo,branch=foo'))
 
439
            from_url('file:///C|/path/to/foo,branch=foo'))
455
440
 
456
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///C:')
457
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///c')
458
 
        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
 
441
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
 
442
        self.assertRaises(InvalidURL, from_url, 'file:///c')
 
443
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
459
444
        # Not a valid _win32 url, no drive letter
460
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///path/to/foo')
 
445
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
461
446
 
462
447
    def test_win32_unc_path_from_url(self):
463
448
        from_url = urlutils._win32_local_path_from_url
464
449
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
465
450
        self.assertEqual('//HOST/path',
466
 
                         from_url('file://HOST/path,branch=foo'))
 
451
            from_url('file://HOST/path,branch=foo'))
467
452
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
468
453
        # we want to use only 2 slashes
469
454
        # Firefox understand only 5 slashes in URL, but it's ugly
470
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:////HOST/path')
471
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://///HOST/path')
472
 
        self.assertRaises(urlutils.InvalidURL, from_url,
473
 
                          'file://////HOST/path')
 
455
        self.assertRaises(InvalidURL, from_url, 'file:////HOST/path')
 
456
        self.assertRaises(InvalidURL, from_url, 'file://///HOST/path')
 
457
        self.assertRaises(InvalidURL, from_url, 'file://////HOST/path')
474
458
        # check for file://C:/ instead of file:///C:/
475
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://C:/path')
 
459
        self.assertRaises(InvalidURL, from_url, 'file://C:/path')
476
460
 
477
461
    def test_win32_extract_drive_letter(self):
478
462
        extract = urlutils._win32_extract_drive_letter
479
463
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
480
 
        self.assertEqual(('file:///d|', '/path'),
481
 
                         extract('file://', '/d|/path'))
482
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/path')
 
464
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
 
465
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
483
466
        # Root drives without slash treated as invalid, see bug #841322
484
467
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
485
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:')
 
468
        self.assertRaises(InvalidURL, extract, 'file://', '/C:')
486
469
        # Invalid without drive separator or following forward slash
487
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C')
488
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:ool')
 
470
        self.assertRaises(InvalidURL, extract, 'file://', '/C')
 
471
        self.assertRaises(InvalidURL, extract, 'file://', '/C:ool')
489
472
 
490
473
    def test_split(self):
491
 
        # Test breezy.urlutils.split()
 
474
        # Test brzlib.urlutils.split()
492
475
        split = urlutils.split
493
476
        if sys.platform == 'win32':
494
 
            self.assertRaises(urlutils.InvalidURL, split,
495
 
                              'file:///path/to/foo')
 
477
            self.assertRaises(InvalidURL, split, 'file:///path/to/foo')
496
478
            self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))
497
479
            self.assertEqual(('file:///C:/', ''), split('file:///C:/'))
498
480
        else:
499
481
            self.assertEqual(('file:///', 'foo'), split('file:///foo'))
500
482
            self.assertEqual(('file:///', ''), split('file:///'))
501
483
 
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', ''),
 
484
        self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo'))
 
485
        self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo/'))
 
486
        self.assertEqual(('http://host/path/to/foo', ''),
508
487
            split('http://host/path/to/foo/', exclude_trailing_slash=False))
509
488
        self.assertEqual(('http://host/', 'path'), split('http://host/path'))
510
489
        self.assertEqual(('http://host/', ''), split('http://host/'))
511
490
        self.assertEqual(('http://host', ''), split('http://host'))
512
 
        self.assertEqual(('http:///nohost', 'path'),
513
 
                         split('http:///nohost/path'))
 
491
        self.assertEqual(('http:///nohost', 'path'), split('http:///nohost/path'))
514
492
 
515
493
        self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
516
 
                         split('random+scheme://user:pass@ahost:port/path'))
 
494
            split('random+scheme://user:pass@ahost:port/path'))
517
495
        self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
518
 
                         split('random+scheme://user:pass@ahost:port/path/'))
 
496
            split('random+scheme://user:pass@ahost:port/path/'))
519
497
        self.assertEqual(('random+scheme://user:pass@ahost:port/', ''),
520
 
                         split('random+scheme://user:pass@ahost:port/'))
 
498
            split('random+scheme://user:pass@ahost:port/'))
521
499
 
522
500
        # relative paths
523
501
        self.assertEqual(('path/to', 'foo'), split('path/to/foo'))
524
502
        self.assertEqual(('path/to', 'foo'), split('path/to/foo/'))
525
503
        self.assertEqual(('path/to/foo', ''),
526
 
                         split('path/to/foo/', exclude_trailing_slash=False))
 
504
            split('path/to/foo/', exclude_trailing_slash=False))
527
505
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
528
506
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
529
507
 
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
508
    def test_split_segment_parameters_raw(self):
558
509
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
559
510
        # Check relative references with absolute paths
560
511
        self.assertEqual(("/some/path", []),
561
 
                         split_segment_parameters_raw("/some/path"))
 
512
            split_segment_parameters_raw("/some/path"))
562
513
        self.assertEqual(("/some/path", ["tip"]),
563
 
                         split_segment_parameters_raw("/some/path,tip"))
 
514
            split_segment_parameters_raw("/some/path,tip"))
564
515
        self.assertEqual(("/some,dir/path", ["tip"]),
565
 
                         split_segment_parameters_raw("/some,dir/path,tip"))
566
 
        self.assertEqual(
567
 
            ("/somedir/path", ["heads%2Ftip"]),
 
516
            split_segment_parameters_raw("/some,dir/path,tip"))
 
517
        self.assertEqual(("/somedir/path", ["heads%2Ftip"]),
568
518
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
569
 
        self.assertEqual(
570
 
            ("/somedir/path", ["heads%2Ftip", "bar"]),
 
519
        self.assertEqual(("/somedir/path", ["heads%2Ftip", "bar"]),
571
520
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
572
521
        # Check relative references with relative paths
573
522
        self.assertEqual(("", ["key1=val1"]),
574
 
                         split_segment_parameters_raw(",key1=val1"))
 
523
            split_segment_parameters_raw(",key1=val1"))
575
524
        self.assertEqual(("foo/", ["key1=val1"]),
576
 
                         split_segment_parameters_raw("foo/,key1=val1"))
 
525
            split_segment_parameters_raw("foo/,key1=val1"))
577
526
        self.assertEqual(("foo", ["key1=val1"]),
578
 
                         split_segment_parameters_raw("foo,key1=val1"))
579
 
        self.assertEqual(
580
 
            ("foo/base,la=bla/other/elements", []),
 
527
            split_segment_parameters_raw("foo,key1=val1"))
 
528
        self.assertEqual(("foo/base,la=bla/other/elements", []),
581
529
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
582
 
        self.assertEqual(
583
 
            ("foo/base,la=bla/other/elements", ["a=b"]),
 
530
        self.assertEqual(("foo/base,la=bla/other/elements", ["a=b"]),
584
531
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
585
532
        # TODO: Check full URLs as well as relative references
586
533
 
588
535
        split_segment_parameters = urlutils.split_segment_parameters
589
536
        # Check relative references with absolute paths
590
537
        self.assertEqual(("/some/path", {}),
591
 
                         split_segment_parameters("/some/path"))
 
538
            split_segment_parameters("/some/path"))
592
539
        self.assertEqual(("/some/path", {"branch": "tip"}),
593
 
                         split_segment_parameters("/some/path,branch=tip"))
 
540
            split_segment_parameters("/some/path,branch=tip"))
594
541
        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"}),
 
542
            split_segment_parameters("/some,dir/path,branch=tip"))
 
543
        self.assertEqual(("/somedir/path", {"ref": "heads%2Ftip"}),
598
544
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
599
545
        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"}),
 
546
            {"ref": "heads%2Ftip", "key1": "val1"}),
 
547
            split_segment_parameters(
 
548
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
 
549
        self.assertEqual(("/somedir/path", {"ref": "heads%2F=tip"}),
605
550
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
606
551
        # Check relative references with relative paths
607
552
        self.assertEqual(("", {"key1": "val1"}),
608
 
                         split_segment_parameters(",key1=val1"))
 
553
            split_segment_parameters(",key1=val1"))
609
554
        self.assertEqual(("foo/", {"key1": "val1"}),
610
 
                         split_segment_parameters("foo/,key1=val1"))
611
 
        self.assertEqual(
612
 
            ("foo/base,key1=val1/other/elements", {}),
 
555
            split_segment_parameters("foo/,key1=val1"))
 
556
        self.assertEqual(("foo/base,key1=val1/other/elements", {}),
613
557
            split_segment_parameters("foo/base,key1=val1/other/elements"))
614
558
        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")
 
559
            {"key2": "val2"}), split_segment_parameters(
 
560
                "foo/base,key1=val1/other/elements,key2=val2"))
620
561
        # TODO: Check full URLs as well as relative references
621
562
 
622
563
    def test_win32_strip_local_trailing_slash(self):
650
591
        self.assertEqual('file://', sts('file://'))
651
592
 
652
593
        self.assertEqual('random+scheme://user:pass@ahost:port/path',
653
 
                         sts('random+scheme://user:pass@ahost:port/path'))
 
594
            sts('random+scheme://user:pass@ahost:port/path'))
654
595
        self.assertEqual('random+scheme://user:pass@ahost:port/path',
655
 
                         sts('random+scheme://user:pass@ahost:port/path/'))
 
596
            sts('random+scheme://user:pass@ahost:port/path/'))
656
597
        self.assertEqual('random+scheme://user:pass@ahost:port/',
657
 
                         sts('random+scheme://user:pass@ahost:port/'))
 
598
            sts('random+scheme://user:pass@ahost:port/'))
658
599
 
659
600
        # Make sure relative paths work too
660
601
        self.assertEqual('path/to/foo', sts('path/to/foo'))
666
607
        # Test that URLs are converted to nice unicode strings for display
667
608
        def test(expected, url, encoding='utf-8'):
668
609
            disp_url = urlutils.unescape_for_display(url, encoding=encoding)
669
 
            self.assertIsInstance(disp_url, str)
 
610
            self.assertIsInstance(disp_url, unicode)
670
611
            self.assertEqual(expected, disp_url)
671
612
 
672
613
        test('http://foo', 'http://foo')
706
647
    def test_escape(self):
707
648
        self.assertEqual('%25', urlutils.escape('%'))
708
649
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
709
 
        self.assertIsInstance(urlutils.escape(u'\xe5'), str)
 
650
        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
710
651
 
711
652
    def test_escape_tildes(self):
712
653
        self.assertEqual('~foo', urlutils.escape('~foo'))
715
656
        self.assertEqual('%', urlutils.unescape('%25'))
716
657
        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
717
658
 
718
 
        self.assertRaises((TypeError, urlutils.InvalidURL),
719
 
                          urlutils.unescape, b'\xe5')
720
 
        self.assertEqual('\xe5', urlutils.unescape('%C3%A5'))
 
659
        self.assertRaises(InvalidURL, urlutils.unescape, u'\xe5')
 
660
        self.assertRaises(InvalidURL, urlutils.unescape, '\xe5')
 
661
        self.assertRaises(InvalidURL, urlutils.unescape, '%E5')
721
662
 
722
663
    def test_escape_unescape(self):
723
664
        self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
730
671
 
731
672
        test('a', 'http://host/', 'http://host/a')
732
673
        test('http://entirely/different', 'sftp://host/branch',
733
 
             'http://entirely/different')
 
674
                    'http://entirely/different')
734
675
        test('../person/feature', 'http://host/branch/mainline',
735
 
             'http://host/branch/person/feature')
 
676
                    'http://host/branch/person/feature')
736
677
        test('..', 'http://host/branch', 'http://host/')
737
 
        test('http://host2/branch', 'http://host1/branch',
738
 
             'http://host2/branch')
 
678
        test('http://host2/branch', 'http://host1/branch', 'http://host2/branch')
739
679
        test('.', 'http://host1/branch', 'http://host1/branch')
740
680
        test('../../../branch/2b', 'file:///home/jelmer/foo/bar/2b',
741
 
             'file:///home/jelmer/branch/2b')
 
681
                    'file:///home/jelmer/branch/2b')
742
682
        test('../../branch/2b', 'sftp://host/home/jelmer/bar/2b',
743
 
             'sftp://host/home/jelmer/branch/2b')
 
683
                    'sftp://host/home/jelmer/branch/2b')
744
684
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
745
 
             'http://host/home/jelmer/branch/feature/%2b')
 
685
                    'http://host/home/jelmer/branch/feature/%2b')
746
686
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
747
 
             'http://host/home/jelmer/branch/feature/2b')
 
687
                    'http://host/home/jelmer/branch/feature/2b')
748
688
        # relative_url should preserve a trailing slash
749
689
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
750
 
             'http://host/home/jelmer/branch/feature/2b/')
 
690
                    'http://host/home/jelmer/branch/feature/2b/')
751
691
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b',
752
 
             'http://host/home/jelmer/branch/feature/2b/')
 
692
                    'http://host/home/jelmer/branch/feature/2b/')
753
693
 
754
694
        # TODO: treat http://host as http://host/
755
695
        #       relative_url is typically called from a branch.base or
756
696
        #       transport.base which always ends with a /
757
 
        # test('a', 'http://host', 'http://host/a')
 
697
        #test('a', 'http://host', 'http://host/a')
758
698
        test('http://host/a', 'http://host', 'http://host/a')
759
 
        # test('.', 'http://host', 'http://host/')
 
699
        #test('.', 'http://host', 'http://host/')
760
700
        test('http://host/', 'http://host', 'http://host/')
761
 
        # test('.', 'http://host/', 'http://host')
 
701
        #test('.', 'http://host/', 'http://host')
762
702
        test('http://host', 'http://host/', 'http://host')
763
703
 
764
704
        # On Windows file:///C:/path/to and file:///D:/other/path
766
706
        if sys.platform == 'win32':
767
707
            # on the same drive
768
708
            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')
 
709
                'file:///C:/path/to', 'file:///C:/other/path')
 
710
            #~next two tests is failed, i.e. urlutils.relative_url expects
 
711
            #~to see normalized file URLs?
 
712
            #~test('../../other/path',
 
713
            #~    'file:///C:/path/to', 'file:///c:/other/path')
 
714
            #~test('../../other/path',
 
715
            #~    'file:///C:/path/to', 'file:///C|/other/path')
776
716
 
777
717
            # check UNC paths too
778
718
            test('../../other/path',
779
 
                 'file://HOST/base/path/to', 'file://HOST/base/other/path')
 
719
                'file://HOST/base/path/to', 'file://HOST/base/other/path')
780
720
            # on different drives
781
721
            test('file:///D:/other/path',
782
 
                 'file:///C:/path/to', 'file:///D:/other/path')
 
722
                'file:///C:/path/to', 'file:///D:/other/path')
783
723
            # TODO: strictly saying in UNC path //HOST/base is full analog
784
724
            # of drive letter for hard disk, and this situation is also
785
725
            # should be exception from rules. [bialix 20071221]
797
737
        self.assertEndsWith(url, '/mytest')
798
738
 
799
739
    def test_non_ascii(self):
 
740
        if win32utils.winver == 'Windows 98':
 
741
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
 
742
 
800
743
        try:
801
744
            os.mkdir(u'dod\xe9')
802
745
        except UnicodeError:
842
785
        self.assertEqual('/foo', result)
843
786
 
844
787
    def test_different_ports(self):
845
 
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
 
788
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
846
789
                              'foo', 'http://bar:80', 'http://bar:81')
847
790
        self.assertEqual(str(e), "URLs differ by more than path:"
848
791
                         " 'http://bar:80' and 'http://bar:81'")
849
792
 
850
793
    def test_different_hosts(self):
851
 
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
 
794
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
852
795
                              'foo', 'http://bar', 'http://baz')
853
796
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
854
797
                         " and 'http://baz'")
855
798
 
856
799
    def test_different_protocol(self):
857
 
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
 
800
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
858
801
                              'foo', 'http://bar', 'ftp://bar')
859
802
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
860
803
                         " and 'ftp://bar'")
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'))