1
# Copyright (C) 2006-2012, 2015, 2016 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Tests for the urlutils wrapper."""
22
from .. import osutils, urlutils
23
from ..errors import (
26
from ..sixish import (
30
from . import features, TestCaseInTempDir, TestCase, TestSkipped
33
class TestUrlToPath(TestCase):
35
def test_basename(self):
36
# breezy.urlutils.basename
37
# Test breezy.urlutils.split()
38
basename = urlutils.basename
39
if sys.platform == 'win32':
40
self.assertRaises(urlutils.InvalidURL, basename,
41
'file:///path/to/foo')
42
self.assertEqual('foo', basename('file:///C|/foo'))
43
self.assertEqual('foo', basename('file:///C:/foo'))
44
self.assertEqual('', basename('file:///C:/'))
46
self.assertEqual('foo', basename('file:///foo'))
47
self.assertEqual('', basename('file:///'))
49
self.assertEqual('foo', basename('http://host/path/to/foo'))
50
self.assertEqual('foo', basename('http://host/path/to/foo/'))
52
'', basename('http://host/path/to/foo/',
53
exclude_trailing_slash=False))
54
self.assertEqual('path', basename('http://host/path'))
55
self.assertEqual('', basename('http://host/'))
56
self.assertEqual('', basename('http://host'))
57
self.assertEqual('path', basename('http:///nohost/path'))
59
self.assertEqual('path', basename(
60
'random+scheme://user:pass@ahost:port/path'))
61
self.assertEqual('path', basename(
62
'random+scheme://user:pass@ahost:port/path/'))
63
self.assertEqual('', basename('random+scheme://user:pass@ahost:port/'))
66
self.assertEqual('foo', basename('path/to/foo'))
67
self.assertEqual('foo', basename('path/to/foo/'))
68
self.assertEqual('', basename('path/to/foo/',
69
exclude_trailing_slash=False))
70
self.assertEqual('foo', basename('path/../foo'))
71
self.assertEqual('foo', basename('../path/foo'))
73
def test_normalize_url_files(self):
74
# Test that local paths are properly normalized
75
normalize_url = urlutils.normalize_url
77
def norm_file(expected, path):
78
url = normalize_url(path)
79
self.assertStartsWith(url, 'file:///')
80
if sys.platform == 'win32':
81
url = url[len('file:///C:'):]
83
url = url[len('file://'):]
85
self.assertEndsWith(url, expected)
87
norm_file('path/to/foo', 'path/to/foo')
88
norm_file('/path/to/foo', '/path/to/foo')
89
norm_file('path/to/foo', '../path/to/foo')
91
# Local paths are assumed to *not* be escaped at all
93
u'uni/\xb5'.encode(osutils.get_user_encoding())
95
# locale cannot handle unicode
98
norm_file('uni/%C2%B5', u'uni/\xb5')
100
norm_file('uni/%25C2%25B5', u'uni/%C2%B5')
101
norm_file('uni/%20b', u'uni/ b')
102
# All the crazy characters get escaped in local paths => file:/// urls
103
# The ' ' character must not be at the end, because on win32
104
# it gets stripped off by ntpath.abspath
105
norm_file('%27%20%3B/%3F%3A%40%26%3D%2B%24%2C%23', "' ;/?:@&=+$,#")
107
def test_normalize_url_hybrid(self):
108
# Anything with a scheme:// should be treated as a hybrid url
109
# which changes what characters get escaped.
110
normalize_url = urlutils.normalize_url
112
eq = self.assertEqual
113
eq('file:///foo/', normalize_url(u'file:///foo/'))
114
eq('file:///foo/%20', normalize_url(u'file:///foo/ '))
115
eq('file:///foo/%20', normalize_url(u'file:///foo/%20'))
116
# Don't escape reserved characters
117
eq('file:///ab_c.d-e/%f:?g&h=i+j;k,L#M$',
118
normalize_url('file:///ab_c.d-e/%f:?g&h=i+j;k,L#M$'))
119
eq('http://ab_c.d-e/%f:?g&h=i+j;k,L#M$',
120
normalize_url('http://ab_c.d-e/%f:?g&h=i+j;k,L#M$'))
122
# Escape unicode characters, but not already escaped chars
123
eq('http://host/ab/%C2%B5/%C2%B5',
124
normalize_url(u'http://host/ab/%C2%B5/\xb5'))
126
# Unescape characters that don't need to be escaped
127
eq('http://host/~bob%2525-._',
128
normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
129
eq('http://host/~bob%2525-._',
130
normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
133
# On Python 2, normalize verifies URLs when they are not unicode
134
# (indicating they did not come from the user)
135
self.assertRaises(urlutils.InvalidURL, normalize_url,
137
self.assertRaises(urlutils.InvalidURL,
138
normalize_url, b'http://host/ ')
140
def test_url_scheme_re(self):
141
# Test paths that may be URLs
142
def test_one(url, scheme_and_path):
143
"""Assert that _url_scheme_re correctly matches
145
:param scheme_and_path: The (scheme, path) that should be matched
146
can be None, to indicate it should not match
148
m = urlutils._url_scheme_re.match(url)
149
if scheme_and_path is None:
150
self.assertEqual(None, m)
152
self.assertEqual(scheme_and_path[0], m.group('scheme'))
153
self.assertEqual(scheme_and_path[1], m.group('path'))
156
test_one('/path', None)
157
test_one('C:/path', None)
158
test_one('../path/to/foo', None)
159
test_one(u'../path/to/fo\xe5', None)
162
test_one('http://host/path/', ('http', 'host/path/'))
163
test_one('sftp://host/path/to/foo', ('sftp', 'host/path/to/foo'))
164
test_one('file:///usr/bin', ('file', '/usr/bin'))
165
test_one('file:///C:/Windows', ('file', '/C:/Windows'))
166
test_one('file:///C|/Windows', ('file', '/C|/Windows'))
167
test_one(u'readonly+sftp://host/path/\xe5',
168
('readonly+sftp', u'host/path/\xe5'))
171
# Can't have slashes or colons in the scheme
172
test_one('/path/to/://foo', None)
173
test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
174
# Must have more than one character for scheme
175
test_one('C://foo', None)
176
test_one('ab://foo', ('ab', 'foo'))
178
def test_dirname(self):
179
# Test breezy.urlutils.dirname()
180
dirname = urlutils.dirname
181
if sys.platform == 'win32':
182
self.assertRaises(urlutils.InvalidURL, dirname,
183
'file:///path/to/foo')
184
self.assertEqual('file:///C|/', dirname('file:///C|/foo'))
185
self.assertEqual('file:///C|/', dirname('file:///C|/'))
187
self.assertEqual('file:///', dirname('file:///foo'))
188
self.assertEqual('file:///', dirname('file:///'))
190
self.assertEqual('http://host/path/to',
191
dirname('http://host/path/to/foo'))
192
self.assertEqual('http://host/path/to',
193
dirname('http://host/path/to/foo/'))
194
self.assertEqual('http://host/path/to/foo',
195
dirname('http://host/path/to/foo/',
196
exclude_trailing_slash=False))
197
self.assertEqual('http://host/', dirname('http://host/path'))
198
self.assertEqual('http://host/', dirname('http://host/'))
199
self.assertEqual('http://host', dirname('http://host'))
200
self.assertEqual('http:///nohost', dirname('http:///nohost/path'))
202
self.assertEqual('random+scheme://user:pass@ahost:port/',
203
dirname('random+scheme://user:pass@ahost:port/path'))
204
self.assertEqual('random+scheme://user:pass@ahost:port/',
205
dirname('random+scheme://user:pass@ahost:port/path/'))
206
self.assertEqual('random+scheme://user:pass@ahost:port/',
207
dirname('random+scheme://user:pass@ahost:port/'))
210
self.assertEqual('path/to', dirname('path/to/foo'))
211
self.assertEqual('path/to', dirname('path/to/foo/'))
212
self.assertEqual('path/to/foo',
213
dirname('path/to/foo/', exclude_trailing_slash=False))
214
self.assertEqual('path/..', dirname('path/../foo'))
215
self.assertEqual('../path', dirname('../path/foo'))
217
def test_is_url(self):
218
self.assertTrue(urlutils.is_url('http://foo/bar'))
219
self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))
220
self.assertTrue(urlutils.is_url('lp:foo/bar'))
221
self.assertTrue(urlutils.is_url('file:///foo/bar'))
222
self.assertFalse(urlutils.is_url(''))
223
self.assertFalse(urlutils.is_url('foo'))
224
self.assertFalse(urlutils.is_url('foo/bar'))
225
self.assertFalse(urlutils.is_url('/foo'))
226
self.assertFalse(urlutils.is_url('/foo/bar'))
227
self.assertFalse(urlutils.is_url('C:/'))
228
self.assertFalse(urlutils.is_url('C:/foo'))
229
self.assertFalse(urlutils.is_url('C:/foo/bar'))
232
def test(expected, *args):
233
joined = urlutils.join(*args)
234
self.assertEqual(expected, joined)
236
# Test relative path joining
237
test('foo', 'foo') # relative fragment with nothing is preserved.
238
test('foo/bar', 'foo', 'bar')
239
test('http://foo/bar', 'http://foo', 'bar')
240
test('http://foo/bar', 'http://foo', '.', 'bar')
241
test('http://foo/baz', 'http://foo', 'bar', '../baz')
242
test('http://foo/bar/baz', 'http://foo', 'bar/baz')
243
test('http://foo/baz', 'http://foo', 'bar/../baz')
244
test('http://foo/baz', 'http://foo/bar/', '../baz')
245
test('lp:foo/bar', 'lp:foo', 'bar')
246
test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')
249
test('http://foo', 'http://foo') # abs url with nothing is preserved.
250
test('http://bar', 'http://foo', 'http://bar')
251
test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')
252
test('file:///bar', 'foo', 'file:///bar')
253
test('http://bar/', 'http://foo', 'http://bar/')
254
test('http://bar/a', 'http://foo', 'http://bar/a')
255
test('http://bar/a/', 'http://foo', 'http://bar/a/')
256
test('lp:bar', 'http://foo', 'lp:bar')
257
test('lp:bar', 'lp:foo', 'lp:bar')
258
test('file:///stuff', 'lp:foo', 'file:///stuff')
261
test('file:///foo', 'file:///', 'foo')
262
test('file:///bar/foo', 'file:///bar/', 'foo')
263
test('http://host/foo', 'http://host/', 'foo')
264
test('http://host/', 'http://host', '')
267
# Cannot go above root
268
# Implicitly at root:
269
self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
270
'http://foo', '../baz')
271
self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
273
# Joining from a path explicitly under the root.
274
self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
275
'http://foo/a', '../../b')
277
def test_joinpath(self):
278
def test(expected, *args):
279
joined = urlutils.joinpath(*args)
280
self.assertEqual(expected, joined)
282
# Test a single element
285
# Test relative path joining
286
test('foo/bar', 'foo', 'bar')
287
test('foo/bar', 'foo', '.', 'bar')
288
test('foo/baz', 'foo', 'bar', '../baz')
289
test('foo/bar/baz', 'foo', 'bar/baz')
290
test('foo/baz', 'foo', 'bar/../baz')
292
# Test joining to an absolute path
294
test('/foo', '/foo', '.')
295
test('/foo/bar', '/foo', 'bar')
296
test('/', '/foo', '..')
298
# Test joining with an absolute path
299
test('/bar', 'foo', '/bar')
301
# Test joining to a path with a trailing slash
302
test('foo/bar', 'foo/', 'bar')
305
# Cannot go above root
306
self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
308
self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
310
self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
313
def test_join_segment_parameters_raw(self):
314
join_segment_parameters_raw = urlutils.join_segment_parameters_raw
315
self.assertEqual("/somedir/path",
316
join_segment_parameters_raw("/somedir/path"))
317
self.assertEqual("/somedir/path,rawdata",
318
join_segment_parameters_raw(
319
"/somedir/path", "rawdata"))
320
self.assertRaises(urlutils.InvalidURLJoin,
321
join_segment_parameters_raw, "/somedir/path",
322
"rawdata1,rawdata2,rawdata3")
323
self.assertEqual("/somedir/path,bla,bar",
324
join_segment_parameters_raw(
325
"/somedir/path", "bla", "bar"))
327
"/somedir,exist=some/path,bla,bar",
328
join_segment_parameters_raw("/somedir,exist=some/path",
330
self.assertRaises(TypeError, join_segment_parameters_raw,
333
def test_join_segment_parameters(self):
334
join_segment_parameters = urlutils.join_segment_parameters
335
self.assertEqual("/somedir/path",
336
join_segment_parameters("/somedir/path", {}))
338
"/somedir/path,key1=val1",
339
join_segment_parameters("/somedir/path", {"key1": "val1"}))
340
self.assertRaises(urlutils.InvalidURLJoin,
341
join_segment_parameters, "/somedir/path",
342
{"branch": "brr,brr,brr"})
344
urlutils.InvalidURLJoin,
345
join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
346
self.assertEqual("/somedir/path,key1=val1,key2=val2",
347
join_segment_parameters("/somedir/path", {
348
"key1": "val1", "key2": "val2"}))
349
self.assertEqual("/somedir/path,key1=val1,key2=val2",
350
join_segment_parameters("/somedir/path,key1=val1", {
352
self.assertEqual("/somedir/path,key1=val2",
353
join_segment_parameters("/somedir/path,key1=val1", {
355
self.assertEqual("/somedir,exist=some/path,key1=val1",
356
join_segment_parameters("/somedir,exist=some/path",
359
"/,key1=val1,key2=val2",
360
join_segment_parameters("/,key1=val1", {"key2": "val2"}))
361
self.assertRaises(TypeError,
362
join_segment_parameters, "/,key1=val1", {"foo": 42})
364
def test_function_type(self):
365
if sys.platform == 'win32':
366
self.assertEqual(urlutils._win32_local_path_to_url,
367
urlutils.local_path_to_url)
368
self.assertEqual(urlutils._win32_local_path_from_url,
369
urlutils.local_path_from_url)
371
self.assertEqual(urlutils._posix_local_path_to_url,
372
urlutils.local_path_to_url)
373
self.assertEqual(urlutils._posix_local_path_from_url,
374
urlutils.local_path_from_url)
376
def test_posix_local_path_to_url(self):
377
to_url = urlutils._posix_local_path_to_url
378
self.assertEqual('file:///path/to/foo',
379
to_url('/path/to/foo'))
381
self.assertEqual('file:///path/to/foo%2Cbar',
382
to_url('/path/to/foo,bar'))
385
result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
387
raise TestSkipped("local encoding cannot handle unicode")
389
self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
390
self.assertTrue(isinstance(result, str))
392
def test_posix_local_path_from_url(self):
393
from_url = urlutils._posix_local_path_from_url
394
self.assertEqual('/path/to/foo',
395
from_url('file:///path/to/foo'))
396
self.assertEqual('/path/to/foo',
397
from_url('file:///path/to/foo,branch=foo'))
398
self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
399
from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
400
self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
401
from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
403
u'/path/to/r\xe4ksm\xf6rg\xe5s',
404
from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
406
self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
408
urlutils.InvalidURL, from_url,
409
'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
411
def test_win32_local_path_to_url(self):
412
to_url = urlutils._win32_local_path_to_url
413
self.assertEqual('file:///C:/path/to/foo',
414
to_url('C:/path/to/foo'))
415
# BOGUS: on win32, ntpath.abspath will strip trailing
416
# whitespace, so this will always fail
417
# Though under linux, it fakes abspath support
418
# and thus will succeed
419
# self.assertEqual('file:///C:/path/to/foo%20',
420
# to_url('C:/path/to/foo '))
421
self.assertEqual('file:///C:/path/to/f%20oo',
422
to_url('C:/path/to/f oo'))
424
self.assertEqual('file:///', to_url('/'))
426
self.assertEqual('file:///C:/path/to/foo%2Cbar',
427
to_url('C:/path/to/foo,bar'))
429
result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
431
raise TestSkipped("local encoding cannot handle unicode")
434
'file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
435
self.assertIsInstance(result, str)
437
def test_win32_unc_path_to_url(self):
438
self.requireFeature(features.win32_feature)
439
to_url = urlutils._win32_local_path_to_url
440
self.assertEqual('file://HOST/path',
441
to_url(r'\\HOST\path'))
442
self.assertEqual('file://HOST/path',
443
to_url('//HOST/path'))
446
result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')
448
raise TestSkipped("local encoding cannot handle unicode")
451
'file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
452
self.assertFalse(isinstance(result, text_type))
454
def test_win32_local_path_from_url(self):
455
from_url = urlutils._win32_local_path_from_url
456
self.assertEqual('C:/path/to/foo',
457
from_url('file:///C|/path/to/foo'))
459
u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
460
from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
462
u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
463
from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
464
self.assertEqual('/', from_url('file:///'))
465
self.assertEqual('C:/path/to/foo',
466
from_url('file:///C|/path/to/foo,branch=foo'))
468
self.assertRaises(urlutils.InvalidURL, from_url, 'file:///C:')
469
self.assertRaises(urlutils.InvalidURL, from_url, 'file:///c')
470
self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
471
# Not a valid _win32 url, no drive letter
472
self.assertRaises(urlutils.InvalidURL, from_url, 'file:///path/to/foo')
474
def test_win32_unc_path_from_url(self):
475
from_url = urlutils._win32_local_path_from_url
476
self.assertEqual('//HOST/path', from_url('file://HOST/path'))
477
self.assertEqual('//HOST/path',
478
from_url('file://HOST/path,branch=foo'))
479
# despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
480
# we want to use only 2 slashes
481
# Firefox understand only 5 slashes in URL, but it's ugly
482
self.assertRaises(urlutils.InvalidURL, from_url, 'file:////HOST/path')
483
self.assertRaises(urlutils.InvalidURL, from_url, 'file://///HOST/path')
484
self.assertRaises(urlutils.InvalidURL, from_url,
485
'file://////HOST/path')
486
# check for file://C:/ instead of file:///C:/
487
self.assertRaises(urlutils.InvalidURL, from_url, 'file://C:/path')
489
def test_win32_extract_drive_letter(self):
490
extract = urlutils._win32_extract_drive_letter
491
self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
492
self.assertEqual(('file:///d|', '/path'),
493
extract('file://', '/d|/path'))
494
self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/path')
495
# Root drives without slash treated as invalid, see bug #841322
496
self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
497
self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:')
498
# Invalid without drive separator or following forward slash
499
self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C')
500
self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:ool')
502
def test_split(self):
503
# Test breezy.urlutils.split()
504
split = urlutils.split
505
if sys.platform == 'win32':
506
self.assertRaises(urlutils.InvalidURL, split,
507
'file:///path/to/foo')
508
self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))
509
self.assertEqual(('file:///C:/', ''), split('file:///C:/'))
511
self.assertEqual(('file:///', 'foo'), split('file:///foo'))
512
self.assertEqual(('file:///', ''), split('file:///'))
514
self.assertEqual(('http://host/path/to', 'foo'),
515
split('http://host/path/to/foo'))
516
self.assertEqual(('http://host/path/to', 'foo'),
517
split('http://host/path/to/foo/'))
519
('http://host/path/to/foo', ''),
520
split('http://host/path/to/foo/', exclude_trailing_slash=False))
521
self.assertEqual(('http://host/', 'path'), split('http://host/path'))
522
self.assertEqual(('http://host/', ''), split('http://host/'))
523
self.assertEqual(('http://host', ''), split('http://host'))
524
self.assertEqual(('http:///nohost', 'path'),
525
split('http:///nohost/path'))
527
self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
528
split('random+scheme://user:pass@ahost:port/path'))
529
self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
530
split('random+scheme://user:pass@ahost:port/path/'))
531
self.assertEqual(('random+scheme://user:pass@ahost:port/', ''),
532
split('random+scheme://user:pass@ahost:port/'))
535
self.assertEqual(('path/to', 'foo'), split('path/to/foo'))
536
self.assertEqual(('path/to', 'foo'), split('path/to/foo/'))
537
self.assertEqual(('path/to/foo', ''),
538
split('path/to/foo/', exclude_trailing_slash=False))
539
self.assertEqual(('path/..', 'foo'), split('path/../foo'))
540
self.assertEqual(('../path', 'foo'), split('../path/foo'))
542
def test_strip_segment_parameters(self):
543
strip_segment_parameters = urlutils.strip_segment_parameters
544
# Check relative references with absolute paths
545
self.assertEqual("/some/path",
546
strip_segment_parameters("/some/path"))
547
self.assertEqual("/some/path",
548
strip_segment_parameters("/some/path,tip"))
549
self.assertEqual("/some,dir/path",
550
strip_segment_parameters("/some,dir/path,tip"))
553
strip_segment_parameters("/somedir/path,heads%2Ftip"))
556
strip_segment_parameters("/somedir/path,heads%2Ftip,bar"))
557
# Check relative references with relative paths
558
self.assertEqual("", strip_segment_parameters(",key1=val1"))
559
self.assertEqual("foo/", strip_segment_parameters("foo/,key1=val1"))
560
self.assertEqual("foo", strip_segment_parameters("foo,key1=val1"))
562
"foo/base,la=bla/other/elements",
563
strip_segment_parameters("foo/base,la=bla/other/elements"))
565
"foo/base,la=bla/other/elements",
566
strip_segment_parameters("foo/base,la=bla/other/elements,a=b"))
567
# TODO: Check full URLs as well as relative references
569
def test_split_segment_parameters_raw(self):
570
split_segment_parameters_raw = urlutils.split_segment_parameters_raw
571
# Check relative references with absolute paths
572
self.assertEqual(("/some/path", []),
573
split_segment_parameters_raw("/some/path"))
574
self.assertEqual(("/some/path", ["tip"]),
575
split_segment_parameters_raw("/some/path,tip"))
576
self.assertEqual(("/some,dir/path", ["tip"]),
577
split_segment_parameters_raw("/some,dir/path,tip"))
579
("/somedir/path", ["heads%2Ftip"]),
580
split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
582
("/somedir/path", ["heads%2Ftip", "bar"]),
583
split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
584
# Check relative references with relative paths
585
self.assertEqual(("", ["key1=val1"]),
586
split_segment_parameters_raw(",key1=val1"))
587
self.assertEqual(("foo/", ["key1=val1"]),
588
split_segment_parameters_raw("foo/,key1=val1"))
589
self.assertEqual(("foo", ["key1=val1"]),
590
split_segment_parameters_raw("foo,key1=val1"))
592
("foo/base,la=bla/other/elements", []),
593
split_segment_parameters_raw("foo/base,la=bla/other/elements"))
595
("foo/base,la=bla/other/elements", ["a=b"]),
596
split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
597
# TODO: Check full URLs as well as relative references
599
def test_split_segment_parameters(self):
600
split_segment_parameters = urlutils.split_segment_parameters
601
# Check relative references with absolute paths
602
self.assertEqual(("/some/path", {}),
603
split_segment_parameters("/some/path"))
604
self.assertEqual(("/some/path", {"branch": "tip"}),
605
split_segment_parameters("/some/path,branch=tip"))
606
self.assertEqual(("/some,dir/path", {"branch": "tip"}),
607
split_segment_parameters("/some,dir/path,branch=tip"))
609
("/somedir/path", {"ref": "heads%2Ftip"}),
610
split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
611
self.assertEqual(("/somedir/path",
612
{"ref": "heads%2Ftip", "key1": "val1"}),
613
split_segment_parameters(
614
"/somedir/path,ref=heads%2Ftip,key1=val1"))
616
("/somedir/path", {"ref": "heads%2F=tip"}),
617
split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
618
# Check relative references with relative paths
619
self.assertEqual(("", {"key1": "val1"}),
620
split_segment_parameters(",key1=val1"))
621
self.assertEqual(("foo/", {"key1": "val1"}),
622
split_segment_parameters("foo/,key1=val1"))
624
("foo/base,key1=val1/other/elements", {}),
625
split_segment_parameters("foo/base,key1=val1/other/elements"))
626
self.assertEqual(("foo/base,key1=val1/other/elements",
627
{"key2": "val2"}), split_segment_parameters(
628
"foo/base,key1=val1/other/elements,key2=val2"))
630
urlutils.InvalidURL, split_segment_parameters,
632
# TODO: Check full URLs as well as relative references
634
def test_win32_strip_local_trailing_slash(self):
635
strip = urlutils._win32_strip_local_trailing_slash
636
self.assertEqual('file://', strip('file://'))
637
self.assertEqual('file:///', strip('file:///'))
638
self.assertEqual('file:///C', strip('file:///C'))
639
self.assertEqual('file:///C:', strip('file:///C:'))
640
self.assertEqual('file:///d|', strip('file:///d|'))
641
self.assertEqual('file:///C:/', strip('file:///C:/'))
642
self.assertEqual('file:///C:/a', strip('file:///C:/a/'))
644
def test_strip_trailing_slash(self):
645
sts = urlutils.strip_trailing_slash
646
if sys.platform == 'win32':
647
self.assertEqual('file:///C|/', sts('file:///C|/'))
648
self.assertEqual('file:///C:/foo', sts('file:///C:/foo'))
649
self.assertEqual('file:///C|/foo', sts('file:///C|/foo/'))
651
self.assertEqual('file:///', sts('file:///'))
652
self.assertEqual('file:///foo', sts('file:///foo'))
653
self.assertEqual('file:///foo', sts('file:///foo/'))
655
self.assertEqual('http://host/', sts('http://host/'))
656
self.assertEqual('http://host/foo', sts('http://host/foo'))
657
self.assertEqual('http://host/foo', sts('http://host/foo/'))
659
# No need to fail just because the slash is missing
660
self.assertEqual('http://host', sts('http://host'))
661
# TODO: jam 20060502 Should this raise InvalidURL?
662
self.assertEqual('file://', sts('file://'))
664
self.assertEqual('random+scheme://user:pass@ahost:port/path',
665
sts('random+scheme://user:pass@ahost:port/path'))
666
self.assertEqual('random+scheme://user:pass@ahost:port/path',
667
sts('random+scheme://user:pass@ahost:port/path/'))
668
self.assertEqual('random+scheme://user:pass@ahost:port/',
669
sts('random+scheme://user:pass@ahost:port/'))
671
# Make sure relative paths work too
672
self.assertEqual('path/to/foo', sts('path/to/foo'))
673
self.assertEqual('path/to/foo', sts('path/to/foo/'))
674
self.assertEqual('../to/foo', sts('../to/foo/'))
675
self.assertEqual('path/../foo', sts('path/../foo/'))
677
def test_unescape_for_display_utf8(self):
678
# Test that URLs are converted to nice unicode strings for display
679
def test(expected, url, encoding='utf-8'):
680
disp_url = urlutils.unescape_for_display(url, encoding=encoding)
681
self.assertIsInstance(disp_url, text_type)
682
self.assertEqual(expected, disp_url)
684
test('http://foo', 'http://foo')
685
if sys.platform == 'win32':
686
test('C:/foo/path', 'file:///C|/foo/path')
687
test('C:/foo/path', 'file:///C:/foo/path')
689
test('/foo/path', 'file:///foo/path')
691
test('http://foo/%2Fbaz', 'http://foo/%2Fbaz')
692
test(u'http://host/r\xe4ksm\xf6rg\xe5s',
693
'http://host/r%C3%A4ksm%C3%B6rg%C3%A5s')
695
# Make sure special escaped characters stay escaped
696
test(u'http://host/%3B%2F%3F%3A%40%26%3D%2B%24%2C%23',
697
'http://host/%3B%2F%3F%3A%40%26%3D%2B%24%2C%23')
699
# Can we handle sections that don't have utf-8 encoding?
700
test(u'http://host/%EE%EE%EE/r\xe4ksm\xf6rg\xe5s',
701
'http://host/%EE%EE%EE/r%C3%A4ksm%C3%B6rg%C3%A5s')
703
# Test encoding into output that can handle some characters
704
test(u'http://host/%EE%EE%EE/r\xe4ksm\xf6rg\xe5s',
705
'http://host/%EE%EE%EE/r%C3%A4ksm%C3%B6rg%C3%A5s',
706
encoding='iso-8859-1')
708
# This one can be encoded into utf8
709
test(u'http://host/\u062c\u0648\u062c\u0648',
710
'http://host/%d8%ac%d9%88%d8%ac%d9%88',
713
# This can't be put into 8859-1 and so stays as escapes
714
test(u'http://host/%d8%ac%d9%88%d8%ac%d9%88',
715
'http://host/%d8%ac%d9%88%d8%ac%d9%88',
716
encoding='iso-8859-1')
718
def test_escape(self):
719
self.assertEqual('%25', urlutils.escape('%'))
720
self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
721
self.assertIsInstance(urlutils.escape(u'\xe5'), str)
723
def test_escape_tildes(self):
724
self.assertEqual('~foo', urlutils.escape('~foo'))
726
def test_unescape(self):
727
self.assertEqual('%', urlutils.unescape('%25'))
728
self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
731
self.assertRaises(urlutils.InvalidURL, urlutils.unescape, u'\xe5')
732
self.assertRaises((TypeError, urlutils.InvalidURL),
733
urlutils.unescape, b'\xe5')
735
self.assertRaises(urlutils.InvalidURL, urlutils.unescape, '%E5')
737
self.assertEqual('\xe5', urlutils.unescape('%C3%A5'))
739
def test_escape_unescape(self):
740
self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
741
self.assertEqual('%', urlutils.unescape(urlutils.escape('%')))
743
def test_relative_url(self):
744
def test(expected, base, other):
745
result = urlutils.relative_url(base, other)
746
self.assertEqual(expected, result)
748
test('a', 'http://host/', 'http://host/a')
749
test('http://entirely/different', 'sftp://host/branch',
750
'http://entirely/different')
751
test('../person/feature', 'http://host/branch/mainline',
752
'http://host/branch/person/feature')
753
test('..', 'http://host/branch', 'http://host/')
754
test('http://host2/branch', 'http://host1/branch',
755
'http://host2/branch')
756
test('.', 'http://host1/branch', 'http://host1/branch')
757
test('../../../branch/2b', 'file:///home/jelmer/foo/bar/2b',
758
'file:///home/jelmer/branch/2b')
759
test('../../branch/2b', 'sftp://host/home/jelmer/bar/2b',
760
'sftp://host/home/jelmer/branch/2b')
761
test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
762
'http://host/home/jelmer/branch/feature/%2b')
763
test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
764
'http://host/home/jelmer/branch/feature/2b')
765
# relative_url should preserve a trailing slash
766
test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
767
'http://host/home/jelmer/branch/feature/2b/')
768
test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b',
769
'http://host/home/jelmer/branch/feature/2b/')
771
# TODO: treat http://host as http://host/
772
# relative_url is typically called from a branch.base or
773
# transport.base which always ends with a /
774
# test('a', 'http://host', 'http://host/a')
775
test('http://host/a', 'http://host', 'http://host/a')
776
# test('.', 'http://host', 'http://host/')
777
test('http://host/', 'http://host', 'http://host/')
778
# test('.', 'http://host/', 'http://host')
779
test('http://host', 'http://host/', 'http://host')
781
# On Windows file:///C:/path/to and file:///D:/other/path
782
# should not use relative url over the non-existent '/' directory.
783
if sys.platform == 'win32':
785
test('../../other/path',
786
'file:///C:/path/to', 'file:///C:/other/path')
787
# ~next two tests is failed, i.e. urlutils.relative_url expects
788
# ~to see normalized file URLs?
789
# ~test('../../other/path',
790
# ~ 'file:///C:/path/to', 'file:///c:/other/path')
791
# ~test('../../other/path',
792
# ~ 'file:///C:/path/to', 'file:///C|/other/path')
794
# check UNC paths too
795
test('../../other/path',
796
'file://HOST/base/path/to', 'file://HOST/base/other/path')
797
# on different drives
798
test('file:///D:/other/path',
799
'file:///C:/path/to', 'file:///D:/other/path')
800
# TODO: strictly saying in UNC path //HOST/base is full analog
801
# of drive letter for hard disk, and this situation is also
802
# should be exception from rules. [bialix 20071221]
805
class TestCwdToURL(TestCaseInTempDir):
806
"""Test that local_path_to_url works based on the cwd"""
809
# This test will fail if getcwd is not ascii
813
url = urlutils.local_path_to_url('.')
814
self.assertEndsWith(url, '/mytest')
816
def test_non_ascii(self):
820
raise TestSkipped('cannot create unicode directory')
824
# On Mac OSX this directory is actually:
825
# u'/dode\u0301' => '/dode\xcc\x81
826
# but we should normalize it back to
827
# u'/dod\xe9' => '/dod\xc3\xa9'
828
url = urlutils.local_path_to_url('.')
829
self.assertEndsWith(url, '/dod%C3%A9')
832
class TestDeriveToLocation(TestCase):
833
"""Test that the mapping of FROM_LOCATION to TO_LOCATION works."""
835
def test_to_locations_derived_from_paths(self):
836
derive = urlutils.derive_to_location
837
self.assertEqual("bar", derive("bar"))
838
self.assertEqual("bar", derive("../bar"))
839
self.assertEqual("bar", derive("/foo/bar"))
840
self.assertEqual("bar", derive("c:/foo/bar"))
841
self.assertEqual("bar", derive("c:bar"))
843
def test_to_locations_derived_from_urls(self):
844
derive = urlutils.derive_to_location
845
self.assertEqual("bar", derive("http://foo/bar"))
846
self.assertEqual("bar", derive("bzr+ssh://foo/bar"))
847
self.assertEqual("foo-bar", derive("lp:foo-bar"))
850
class TestRebaseURL(TestCase):
851
"""Test the behavior of rebase_url."""
853
def test_non_relative(self):
854
result = urlutils.rebase_url('file://foo', 'file://foo',
856
self.assertEqual('file://foo', result)
857
result = urlutils.rebase_url('/foo', 'file://foo',
859
self.assertEqual('/foo', result)
861
def test_different_ports(self):
862
e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
863
'foo', 'http://bar:80', 'http://bar:81')
864
self.assertEqual(str(e), "URLs differ by more than path:"
865
" 'http://bar:80' and 'http://bar:81'")
867
def test_different_hosts(self):
868
e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
869
'foo', 'http://bar', 'http://baz')
870
self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
873
def test_different_protocol(self):
874
e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
875
'foo', 'http://bar', 'ftp://bar')
876
self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
879
def test_rebase_success(self):
880
self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',
884
urlutils.rebase_url('bar', 'http://baz/qux', 'http://baz/'))
886
'.', urlutils.rebase_url('foo', 'http://bar/', 'http://bar/foo/'))
889
urlutils.rebase_url('../bar', 'http://baz/qux/foo', 'http://baz/'))
891
def test_determine_relative_path(self):
892
self.assertEqual('../../baz/bar',
893
urlutils.determine_relative_path(
894
'/qux/quxx', '/baz/bar'))
895
self.assertEqual('..',
896
urlutils.determine_relative_path(
898
self.assertEqual('baz',
899
urlutils.determine_relative_path(
901
self.assertEqual('.', urlutils.determine_relative_path(
905
class TestParseURL(TestCase):
907
def test_parse_simple(self):
908
parsed = urlutils.parse_url('http://example.com:80/one')
909
self.assertEqual(('http', None, None, 'example.com', 80, '/one'),
913
parsed = urlutils.parse_url('http://[1:2:3::40]/one')
914
self.assertEqual(('http', None, None, '1:2:3::40', None, '/one'),
917
def test_ipv6_port(self):
918
parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
919
self.assertEqual(('http', None, None, '1:2:3::40', 80, '/one'),
923
class TestURL(TestCase):
925
def test_parse_simple(self):
926
parsed = urlutils.URL.from_string('http://example.com:80/one')
927
self.assertEqual('http', parsed.scheme)
928
self.assertIs(None, parsed.user)
929
self.assertIs(None, parsed.password)
930
self.assertEqual('example.com', parsed.host)
931
self.assertEqual(80, parsed.port)
932
self.assertEqual('/one', parsed.path)
935
parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
936
self.assertEqual('http', parsed.scheme)
937
self.assertIs(None, parsed.port)
938
self.assertIs(None, parsed.user)
939
self.assertIs(None, parsed.password)
940
self.assertEqual('1:2:3::40', parsed.host)
941
self.assertEqual('/one', parsed.path)
943
def test_ipv6_port(self):
944
parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
945
self.assertEqual('http', parsed.scheme)
946
self.assertEqual('1:2:3::40', parsed.host)
947
self.assertIs(None, parsed.user)
948
self.assertIs(None, parsed.password)
949
self.assertEqual(80, parsed.port)
950
self.assertEqual('/one', parsed.path)
952
def test_quoted(self):
953
parsed = urlutils.URL.from_string(
954
'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
955
self.assertEqual(parsed.quoted_host, 'ex%41mple.com')
956
self.assertEqual(parsed.host, 'exAmple.com')
957
self.assertEqual(parsed.port, 2222)
958
self.assertEqual(parsed.quoted_user, 'ro%62ey')
959
self.assertEqual(parsed.user, 'robey')
960
self.assertEqual(parsed.quoted_password, 'h%40t')
961
self.assertEqual(parsed.password, 'h@t')
962
self.assertEqual(parsed.path, '/path')
965
parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
966
parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
967
self.assertEqual(parsed1, parsed2)
968
self.assertEqual(parsed1, parsed1)
969
parsed2.path = '/two'
970
self.assertNotEqual(parsed1, parsed2)
973
parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
975
"<URL('http', None, None, '1:2:3::40', 80, '/one')>",
979
parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
980
self.assertEqual('http://[1:2:3::40]:80/one', str(parsed))
982
def test__combine_paths(self):
983
combine = urlutils.URL._combine_paths
984
self.assertEqual('/home/sarah/project/foo',
985
combine('/home/sarah', 'project/foo'))
986
self.assertEqual('/etc',
987
combine('/home/sarah', '../../etc'))
988
self.assertEqual('/etc',
989
combine('/home/sarah', '../../../etc'))
990
self.assertEqual('/etc',
991
combine('/home/sarah', '/etc'))
993
def test_clone(self):
994
url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
995
url1 = url.clone("two")
996
self.assertEqual("/one/two", url1.path)
997
url2 = url.clone("/two")
998
self.assertEqual("/two", url2.path)
1000
self.assertIsNot(url, url3)
1001
self.assertEqual(url, url3)
1003
def test_parse_empty_port(self):
1004
parsed = urlutils.URL.from_string('http://example.com:/one')
1005
self.assertEqual('http', parsed.scheme)
1006
self.assertIs(None, parsed.user)
1007
self.assertIs(None, parsed.password)
1008
self.assertEqual('example.com', parsed.host)
1009
self.assertIs(None, parsed.port)
1010
self.assertEqual('/one', parsed.path)
1013
class TestFileRelpath(TestCase):
1015
# GZ 2011-11-18: A way to override all path handling functions to one
1016
# platform or another for testing would be nice.
1018
def _with_posix_paths(self):
1019
self.overrideAttr(urlutils, "local_path_from_url",
1020
urlutils._posix_local_path_from_url)
1021
self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH", len("file:///"))
1022
self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
1023
self.overrideAttr(osutils, "abspath", osutils._posix_abspath)
1024
self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
1025
self.overrideAttr(osutils, "pathjoin", osutils.posixpath.join)
1026
self.overrideAttr(osutils, "split", osutils.posixpath.split)
1027
self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 1)
1029
def _with_win32_paths(self):
1030
self.overrideAttr(urlutils, "local_path_from_url",
1031
urlutils._win32_local_path_from_url)
1032
self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH",
1033
urlutils.WIN32_MIN_ABS_FILEURL_LENGTH)
1034
self.overrideAttr(osutils, "abspath", osutils._win32_abspath)
1035
self.overrideAttr(osutils, "normpath", osutils._win32_normpath)
1036
self.overrideAttr(osutils, "pathjoin", osutils._win32_pathjoin)
1037
self.overrideAttr(osutils, "split", osutils.ntpath.split)
1038
self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 3)
1040
def test_same_url_posix(self):
1041
self._with_posix_paths()
1042
self.assertEqual("",
1043
urlutils.file_relpath("file:///a", "file:///a"))
1044
self.assertEqual("",
1045
urlutils.file_relpath("file:///a", "file:///a/"))
1046
self.assertEqual("",
1047
urlutils.file_relpath("file:///a/", "file:///a"))
1049
def test_same_url_win32(self):
1050
self._with_win32_paths()
1051
self.assertEqual("",
1052
urlutils.file_relpath("file:///A:/", "file:///A:/"))
1053
self.assertEqual("",
1054
urlutils.file_relpath("file:///A|/", "file:///A:/"))
1056
"", urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
1058
"", urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
1060
"", urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
1062
def test_child_posix(self):
1063
self._with_posix_paths()
1065
"b", urlutils.file_relpath("file:///a", "file:///a/b"))
1067
"b", urlutils.file_relpath("file:///a/", "file:///a/b"))
1069
"b/c", urlutils.file_relpath("file:///a", "file:///a/b/c"))
1071
def test_child_win32(self):
1072
self._with_win32_paths()
1074
"b", urlutils.file_relpath("file:///A:/", "file:///A:/b"))
1076
"b", urlutils.file_relpath("file:///A|/", "file:///A:/b"))
1078
"c", urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
1080
"c", urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
1082
"c/d", urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
1084
def test_sibling_posix(self):
1085
self._with_posix_paths()
1088
urlutils.file_relpath, "file:///a/b", "file:///a/c")
1091
urlutils.file_relpath, "file:///a/b/", "file:///a/c")
1094
urlutils.file_relpath, "file:///a/b/", "file:///a/c/")
1096
def test_sibling_win32(self):
1097
self._with_win32_paths()
1100
urlutils.file_relpath, "file:///A:/b", "file:///A:/c")
1103
urlutils.file_relpath, "file:///A:/b/", "file:///A:/c")
1106
urlutils.file_relpath, "file:///A:/b/", "file:///A:/c/")
1108
def test_parent_posix(self):
1109
self._with_posix_paths()
1110
self.assertRaises(PathNotChild,
1111
urlutils.file_relpath, "file:///a/b", "file:///a")
1112
self.assertRaises(PathNotChild,
1113
urlutils.file_relpath, "file:///a/b", "file:///a/")
1115
def test_parent_win32(self):
1116
self._with_win32_paths()
1119
urlutils.file_relpath, "file:///A:/b", "file:///A:/")
1122
urlutils.file_relpath, "file:///A:/b/c", "file:///A:/b")
1125
class QuoteTests(TestCase):
1127
def test_quote(self):
1128
self.assertEqual('abc%20def', urlutils.quote('abc def'))
1129
self.assertEqual('abc%2Fdef', urlutils.quote('abc/def', safe=''))
1130
self.assertEqual('abc/def', urlutils.quote('abc/def', safe='/'))
1132
def test_quote_tildes(self):
1133
# Whether ~ is quoted by default depends on the python version
1134
if sys.version_info[:2] >= (3, 7):
1135
# https://docs.python.org/3/whatsnew/3.7.html#urllib-parse
1136
self.assertEqual('~foo', urlutils.quote('~foo'))
1138
self.assertEqual('%7Efoo', urlutils.quote('~foo'))
1139
self.assertEqual('~foo', urlutils.quote('~foo', safe='/~'))
1141
def test_unquote(self):
1142
self.assertEqual('%', urlutils.unquote('%25'))
1144
self.assertEqual('\xe5', urlutils.unquote('%C3%A5'))
1146
self.assertEqual('\xc3\xa5', urlutils.unquote('%C3%A5'))
1147
self.assertEqual(u"\xe5", urlutils.unquote(u'\xe5'))
1149
def test_unquote_to_bytes(self):
1150
self.assertEqual(b'%', urlutils.unquote_to_bytes('%25'))
1151
self.assertEqual(b'\xc3\xa5', urlutils.unquote_to_bytes('%C3%A5'))
added
removed
breezy/tests/test_urlutils.py
