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, win32utils
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/', exclude_trailing_slash=False))
53
self.assertEqual('path', basename('http://host/path'))
54
self.assertEqual('', basename('http://host/'))
55
self.assertEqual('', basename('http://host'))
56
self.assertEqual('path', basename('http:///nohost/path'))
58
self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path'))
59
self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path/'))
60
self.assertEqual('', basename('random+scheme://user:pass@ahost:port/'))
63
self.assertEqual('foo', basename('path/to/foo'))
64
self.assertEqual('foo', basename('path/to/foo/'))
65
self.assertEqual('', basename('path/to/foo/',
66
exclude_trailing_slash=False))
67
self.assertEqual('foo', basename('path/../foo'))
68
self.assertEqual('foo', basename('../path/foo'))
70
def test_normalize_url_files(self):
71
# Test that local paths are properly normalized
72
normalize_url = urlutils.normalize_url
74
def norm_file(expected, path):
75
url = normalize_url(path)
76
self.assertStartsWith(url, 'file:///')
77
if sys.platform == 'win32':
78
url = url[len('file:///C:'):]
80
url = url[len('file://'):]
82
self.assertEndsWith(url, expected)
84
norm_file('path/to/foo', 'path/to/foo')
85
norm_file('/path/to/foo', '/path/to/foo')
86
norm_file('path/to/foo', '../path/to/foo')
88
# Local paths are assumed to *not* be escaped at all
90
u'uni/\xb5'.encode(osutils.get_user_encoding())
92
# locale cannot handle unicode
95
norm_file('uni/%C2%B5', u'uni/\xb5')
97
norm_file('uni/%25C2%25B5', u'uni/%C2%B5')
98
norm_file('uni/%20b', u'uni/ b')
99
# All the crazy characters get escaped in local paths => file:/// urls
100
# The ' ' character must not be at the end, because on win32
101
# it gets stripped off by ntpath.abspath
102
norm_file('%27%20%3B/%3F%3A%40%26%3D%2B%24%2C%23', "' ;/?:@&=+$,#")
104
def test_normalize_url_hybrid(self):
105
# Anything with a scheme:// should be treated as a hybrid url
106
# which changes what characters get escaped.
107
normalize_url = urlutils.normalize_url
109
eq = self.assertEqual
110
eq('file:///foo/', normalize_url(u'file:///foo/'))
111
eq('file:///foo/%20', normalize_url(u'file:///foo/ '))
112
eq('file:///foo/%20', normalize_url(u'file:///foo/%20'))
113
# Don't escape reserved characters
114
eq('file:///ab_c.d-e/%f:?g&h=i+j;k,L#M$',
115
normalize_url('file:///ab_c.d-e/%f:?g&h=i+j;k,L#M$'))
116
eq('http://ab_c.d-e/%f:?g&h=i+j;k,L#M$',
117
normalize_url('http://ab_c.d-e/%f:?g&h=i+j;k,L#M$'))
119
# Escape unicode characters, but not already escaped chars
120
eq('http://host/ab/%C2%B5/%C2%B5',
121
normalize_url(u'http://host/ab/%C2%B5/\xb5'))
123
# Unescape characters that don't need to be escaped
124
eq('http://host/~bob%2525-._',
125
normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
126
eq('http://host/~bob%2525-._',
127
normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
129
# Normalize verifies URLs when they are not unicode
130
# (indicating they did not come from the user)
131
self.assertRaises(urlutils.InvalidURL, normalize_url,
133
self.assertRaises(urlutils.InvalidURL, normalize_url, 'http://host/ ')
135
def test_url_scheme_re(self):
136
# Test paths that may be URLs
137
def test_one(url, scheme_and_path):
138
"""Assert that _url_scheme_re correctly matches
140
:param scheme_and_path: The (scheme, path) that should be matched
141
can be None, to indicate it should not match
143
m = urlutils._url_scheme_re.match(url)
144
if scheme_and_path is None:
145
self.assertEqual(None, m)
147
self.assertEqual(scheme_and_path[0], m.group('scheme'))
148
self.assertEqual(scheme_and_path[1], m.group('path'))
151
test_one('/path', None)
152
test_one('C:/path', None)
153
test_one('../path/to/foo', None)
154
test_one(u'../path/to/fo\xe5', None)
157
test_one('http://host/path/', ('http', 'host/path/'))
158
test_one('sftp://host/path/to/foo', ('sftp', 'host/path/to/foo'))
159
test_one('file:///usr/bin', ('file', '/usr/bin'))
160
test_one('file:///C:/Windows', ('file', '/C:/Windows'))
161
test_one('file:///C|/Windows', ('file', '/C|/Windows'))
162
test_one(u'readonly+sftp://host/path/\xe5', ('readonly+sftp', u'host/path/\xe5'))
165
# Can't have slashes or colons in the scheme
166
test_one('/path/to/://foo', None)
167
test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
168
# Must have more than one character for scheme
169
test_one('C://foo', None)
170
test_one('ab://foo', ('ab', 'foo'))
172
def test_dirname(self):
173
# Test breezy.urlutils.dirname()
174
dirname = urlutils.dirname
175
if sys.platform == 'win32':
176
self.assertRaises(urlutils.InvalidURL, dirname,
177
'file:///path/to/foo')
178
self.assertEqual('file:///C|/', dirname('file:///C|/foo'))
179
self.assertEqual('file:///C|/', dirname('file:///C|/'))
181
self.assertEqual('file:///', dirname('file:///foo'))
182
self.assertEqual('file:///', dirname('file:///'))
184
self.assertEqual('http://host/path/to', dirname('http://host/path/to/foo'))
185
self.assertEqual('http://host/path/to', dirname('http://host/path/to/foo/'))
186
self.assertEqual('http://host/path/to/foo',
187
dirname('http://host/path/to/foo/', exclude_trailing_slash=False))
188
self.assertEqual('http://host/', dirname('http://host/path'))
189
self.assertEqual('http://host/', dirname('http://host/'))
190
self.assertEqual('http://host', dirname('http://host'))
191
self.assertEqual('http:///nohost', dirname('http:///nohost/path'))
193
self.assertEqual('random+scheme://user:pass@ahost:port/',
194
dirname('random+scheme://user:pass@ahost:port/path'))
195
self.assertEqual('random+scheme://user:pass@ahost:port/',
196
dirname('random+scheme://user:pass@ahost:port/path/'))
197
self.assertEqual('random+scheme://user:pass@ahost:port/',
198
dirname('random+scheme://user:pass@ahost:port/'))
201
self.assertEqual('path/to', dirname('path/to/foo'))
202
self.assertEqual('path/to', dirname('path/to/foo/'))
203
self.assertEqual('path/to/foo',
204
dirname('path/to/foo/', exclude_trailing_slash=False))
205
self.assertEqual('path/..', dirname('path/../foo'))
206
self.assertEqual('../path', dirname('../path/foo'))
208
def test_is_url(self):
209
self.assertTrue(urlutils.is_url('http://foo/bar'))
210
self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))
211
self.assertTrue(urlutils.is_url('lp:foo/bar'))
212
self.assertTrue(urlutils.is_url('file:///foo/bar'))
213
self.assertFalse(urlutils.is_url(''))
214
self.assertFalse(urlutils.is_url('foo'))
215
self.assertFalse(urlutils.is_url('foo/bar'))
216
self.assertFalse(urlutils.is_url('/foo'))
217
self.assertFalse(urlutils.is_url('/foo/bar'))
218
self.assertFalse(urlutils.is_url('C:/'))
219
self.assertFalse(urlutils.is_url('C:/foo'))
220
self.assertFalse(urlutils.is_url('C:/foo/bar'))
223
def test(expected, *args):
224
joined = urlutils.join(*args)
225
self.assertEqual(expected, joined)
227
# Test relative path joining
228
test('foo', 'foo') # relative fragment with nothing is preserved.
229
test('foo/bar', 'foo', 'bar')
230
test('http://foo/bar', 'http://foo', 'bar')
231
test('http://foo/bar', 'http://foo', '.', 'bar')
232
test('http://foo/baz', 'http://foo', 'bar', '../baz')
233
test('http://foo/bar/baz', 'http://foo', 'bar/baz')
234
test('http://foo/baz', 'http://foo', 'bar/../baz')
235
test('http://foo/baz', 'http://foo/bar/', '../baz')
236
test('lp:foo/bar', 'lp:foo', 'bar')
237
test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')
240
test('http://foo', 'http://foo') # abs url with nothing is preserved.
241
test('http://bar', 'http://foo', 'http://bar')
242
test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')
243
test('file:///bar', 'foo', 'file:///bar')
244
test('http://bar/', 'http://foo', 'http://bar/')
245
test('http://bar/a', 'http://foo', 'http://bar/a')
246
test('http://bar/a/', 'http://foo', 'http://bar/a/')
247
test('lp:bar', 'http://foo', 'lp:bar')
248
test('lp:bar', 'lp:foo', 'lp:bar')
249
test('file:///stuff', 'lp:foo', 'file:///stuff')
252
test('file:///foo', 'file:///', 'foo')
253
test('file:///bar/foo', 'file:///bar/', 'foo')
254
test('http://host/foo', 'http://host/', 'foo')
255
test('http://host/', 'http://host', '')
258
# Cannot go above root
259
# Implicitly at root:
260
self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
261
'http://foo', '../baz')
262
self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
264
# Joining from a path explicitly under the root.
265
self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
266
'http://foo/a', '../../b')
268
def test_joinpath(self):
269
def test(expected, *args):
270
joined = urlutils.joinpath(*args)
271
self.assertEqual(expected, joined)
273
# Test a single element
276
# Test relative path joining
277
test('foo/bar', 'foo', 'bar')
278
test('foo/bar', 'foo', '.', 'bar')
279
test('foo/baz', 'foo', 'bar', '../baz')
280
test('foo/bar/baz', 'foo', 'bar/baz')
281
test('foo/baz', 'foo', 'bar/../baz')
283
# Test joining to an absolute path
285
test('/foo', '/foo', '.')
286
test('/foo/bar', '/foo', 'bar')
287
test('/', '/foo', '..')
289
# Test joining with an absolute path
290
test('/bar', 'foo', '/bar')
292
# Test joining to a path with a trailing slash
293
test('foo/bar', 'foo/', 'bar')
296
# Cannot go above root
297
self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
299
self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
301
self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
304
def test_join_segment_parameters_raw(self):
305
join_segment_parameters_raw = urlutils.join_segment_parameters_raw
306
self.assertEqual("/somedir/path",
307
join_segment_parameters_raw("/somedir/path"))
308
self.assertEqual("/somedir/path,rawdata",
309
join_segment_parameters_raw("/somedir/path", "rawdata"))
310
self.assertRaises(urlutils.InvalidURLJoin,
311
join_segment_parameters_raw, "/somedir/path",
312
"rawdata1,rawdata2,rawdata3")
313
self.assertEqual("/somedir/path,bla,bar",
314
join_segment_parameters_raw("/somedir/path", "bla", "bar"))
315
self.assertEqual("/somedir,exist=some/path,bla,bar",
316
join_segment_parameters_raw("/somedir,exist=some/path",
318
self.assertRaises(TypeError, join_segment_parameters_raw,
321
def test_join_segment_parameters(self):
322
join_segment_parameters = urlutils.join_segment_parameters
323
self.assertEqual("/somedir/path",
324
join_segment_parameters("/somedir/path", {}))
325
self.assertEqual("/somedir/path,key1=val1",
326
join_segment_parameters("/somedir/path", {"key1": "val1"}))
327
self.assertRaises(urlutils.InvalidURLJoin,
328
join_segment_parameters, "/somedir/path",
329
{"branch": "brr,brr,brr"})
330
self.assertRaises(urlutils.InvalidURLJoin,
331
join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
332
self.assertEqual("/somedir/path,key1=val1,key2=val2",
333
join_segment_parameters("/somedir/path", {
334
"key1": "val1", "key2": "val2"}))
335
self.assertEqual("/somedir/path,key1=val1,key2=val2",
336
join_segment_parameters("/somedir/path,key1=val1", {
338
self.assertEqual("/somedir/path,key1=val2",
339
join_segment_parameters("/somedir/path,key1=val1", {
341
self.assertEqual("/somedir,exist=some/path,key1=val1",
342
join_segment_parameters("/somedir,exist=some/path",
344
self.assertEqual("/,key1=val1,key2=val2",
345
join_segment_parameters("/,key1=val1", {"key2": "val2"}))
346
self.assertRaises(TypeError,
347
join_segment_parameters, "/,key1=val1", {"foo": 42})
349
def test_function_type(self):
350
if sys.platform == 'win32':
351
self.assertEqual(urlutils._win32_local_path_to_url,
352
urlutils.local_path_to_url)
353
self.assertEqual(urlutils._win32_local_path_from_url,
354
urlutils.local_path_from_url)
356
self.assertEqual(urlutils._posix_local_path_to_url,
357
urlutils.local_path_to_url)
358
self.assertEqual(urlutils._posix_local_path_from_url,
359
urlutils.local_path_from_url)
361
def test_posix_local_path_to_url(self):
362
to_url = urlutils._posix_local_path_to_url
363
self.assertEqual('file:///path/to/foo',
364
to_url('/path/to/foo'))
366
self.assertEqual('file:///path/to/foo%2Cbar',
367
to_url('/path/to/foo,bar'))
370
result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
372
raise TestSkipped("local encoding cannot handle unicode")
374
self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
375
self.assertTrue(isinstance(result, str))
377
def test_posix_local_path_from_url(self):
378
from_url = urlutils._posix_local_path_from_url
379
self.assertEqual('/path/to/foo',
380
from_url('file:///path/to/foo'))
381
self.assertEqual('/path/to/foo',
382
from_url('file:///path/to/foo,branch=foo'))
383
self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
384
from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
385
self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
386
from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
387
self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
388
from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
390
self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
392
urlutils.InvalidURL, from_url,
393
'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
395
def test_win32_local_path_to_url(self):
396
to_url = urlutils._win32_local_path_to_url
397
self.assertEqual('file:///C:/path/to/foo',
398
to_url('C:/path/to/foo'))
399
# BOGUS: on win32, ntpath.abspath will strip trailing
400
# whitespace, so this will always fail
401
# Though under linux, it fakes abspath support
402
# and thus will succeed
403
# self.assertEqual('file:///C:/path/to/foo%20',
404
# to_url('C:/path/to/foo '))
405
self.assertEqual('file:///C:/path/to/f%20oo',
406
to_url('C:/path/to/f oo'))
408
self.assertEqual('file:///', to_url('/'))
410
self.assertEqual('file:///C:/path/to/foo%2Cbar',
411
to_url('C:/path/to/foo,bar'))
413
result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
415
raise TestSkipped("local encoding cannot handle unicode")
417
self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
418
self.assertFalse(isinstance(result, text_type))
420
def test_win32_unc_path_to_url(self):
421
self.requireFeature(features.win32_feature)
422
to_url = urlutils._win32_local_path_to_url
423
self.assertEqual('file://HOST/path',
424
to_url(r'\\HOST\path'))
425
self.assertEqual('file://HOST/path',
426
to_url('//HOST/path'))
429
result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')
431
raise TestSkipped("local encoding cannot handle unicode")
433
self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
434
self.assertFalse(isinstance(result, text_type))
436
def test_win32_local_path_from_url(self):
437
from_url = urlutils._win32_local_path_from_url
438
self.assertEqual('C:/path/to/foo',
439
from_url('file:///C|/path/to/foo'))
440
self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
441
from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
442
self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
443
from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
444
self.assertEqual('/', from_url('file:///'))
445
self.assertEqual('C:/path/to/foo',
446
from_url('file:///C|/path/to/foo,branch=foo'))
448
self.assertRaises(urlutils.InvalidURL, from_url, 'file:///C:')
449
self.assertRaises(urlutils.InvalidURL, from_url, 'file:///c')
450
self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
451
# Not a valid _win32 url, no drive letter
452
self.assertRaises(urlutils.InvalidURL, from_url, 'file:///path/to/foo')
454
def test_win32_unc_path_from_url(self):
455
from_url = urlutils._win32_local_path_from_url
456
self.assertEqual('//HOST/path', from_url('file://HOST/path'))
457
self.assertEqual('//HOST/path',
458
from_url('file://HOST/path,branch=foo'))
459
# despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
460
# we want to use only 2 slashes
461
# Firefox understand only 5 slashes in URL, but it's ugly
462
self.assertRaises(urlutils.InvalidURL, from_url, 'file:////HOST/path')
463
self.assertRaises(urlutils.InvalidURL, from_url, 'file://///HOST/path')
464
self.assertRaises(urlutils.InvalidURL, from_url, 'file://////HOST/path')
465
# check for file://C:/ instead of file:///C:/
466
self.assertRaises(urlutils.InvalidURL, from_url, 'file://C:/path')
468
def test_win32_extract_drive_letter(self):
469
extract = urlutils._win32_extract_drive_letter
470
self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
471
self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
472
self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/path')
473
# Root drives without slash treated as invalid, see bug #841322
474
self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
475
self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:')
476
# Invalid without drive separator or following forward slash
477
self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C')
478
self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:ool')
480
def test_split(self):
481
# Test breezy.urlutils.split()
482
split = urlutils.split
483
if sys.platform == 'win32':
484
self.assertRaises(urlutils.InvalidURL, split, 'file:///path/to/foo')
485
self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))
486
self.assertEqual(('file:///C:/', ''), split('file:///C:/'))
488
self.assertEqual(('file:///', 'foo'), split('file:///foo'))
489
self.assertEqual(('file:///', ''), split('file:///'))
491
self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo'))
492
self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo/'))
493
self.assertEqual(('http://host/path/to/foo', ''),
494
split('http://host/path/to/foo/', exclude_trailing_slash=False))
495
self.assertEqual(('http://host/', 'path'), split('http://host/path'))
496
self.assertEqual(('http://host/', ''), split('http://host/'))
497
self.assertEqual(('http://host', ''), split('http://host'))
498
self.assertEqual(('http:///nohost', 'path'), split('http:///nohost/path'))
500
self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
501
split('random+scheme://user:pass@ahost:port/path'))
502
self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
503
split('random+scheme://user:pass@ahost:port/path/'))
504
self.assertEqual(('random+scheme://user:pass@ahost:port/', ''),
505
split('random+scheme://user:pass@ahost:port/'))
508
self.assertEqual(('path/to', 'foo'), split('path/to/foo'))
509
self.assertEqual(('path/to', 'foo'), split('path/to/foo/'))
510
self.assertEqual(('path/to/foo', ''),
511
split('path/to/foo/', exclude_trailing_slash=False))
512
self.assertEqual(('path/..', 'foo'), split('path/../foo'))
513
self.assertEqual(('../path', 'foo'), split('../path/foo'))
515
def test_split_segment_parameters_raw(self):
516
split_segment_parameters_raw = urlutils.split_segment_parameters_raw
517
# Check relative references with absolute paths
518
self.assertEqual(("/some/path", []),
519
split_segment_parameters_raw("/some/path"))
520
self.assertEqual(("/some/path", ["tip"]),
521
split_segment_parameters_raw("/some/path,tip"))
522
self.assertEqual(("/some,dir/path", ["tip"]),
523
split_segment_parameters_raw("/some,dir/path,tip"))
524
self.assertEqual(("/somedir/path", ["heads%2Ftip"]),
525
split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
526
self.assertEqual(("/somedir/path", ["heads%2Ftip", "bar"]),
527
split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
528
# Check relative references with relative paths
529
self.assertEqual(("", ["key1=val1"]),
530
split_segment_parameters_raw(",key1=val1"))
531
self.assertEqual(("foo/", ["key1=val1"]),
532
split_segment_parameters_raw("foo/,key1=val1"))
533
self.assertEqual(("foo", ["key1=val1"]),
534
split_segment_parameters_raw("foo,key1=val1"))
535
self.assertEqual(("foo/base,la=bla/other/elements", []),
536
split_segment_parameters_raw("foo/base,la=bla/other/elements"))
537
self.assertEqual(("foo/base,la=bla/other/elements", ["a=b"]),
538
split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
539
# TODO: Check full URLs as well as relative references
541
def test_split_segment_parameters(self):
542
split_segment_parameters = urlutils.split_segment_parameters
543
# Check relative references with absolute paths
544
self.assertEqual(("/some/path", {}),
545
split_segment_parameters("/some/path"))
546
self.assertEqual(("/some/path", {"branch": "tip"}),
547
split_segment_parameters("/some/path,branch=tip"))
548
self.assertEqual(("/some,dir/path", {"branch": "tip"}),
549
split_segment_parameters("/some,dir/path,branch=tip"))
550
self.assertEqual(("/somedir/path", {"ref": "heads%2Ftip"}),
551
split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
552
self.assertEqual(("/somedir/path",
553
{"ref": "heads%2Ftip", "key1": "val1"}),
554
split_segment_parameters(
555
"/somedir/path,ref=heads%2Ftip,key1=val1"))
556
self.assertEqual(("/somedir/path", {"ref": "heads%2F=tip"}),
557
split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
558
# Check relative references with relative paths
559
self.assertEqual(("", {"key1": "val1"}),
560
split_segment_parameters(",key1=val1"))
561
self.assertEqual(("foo/", {"key1": "val1"}),
562
split_segment_parameters("foo/,key1=val1"))
563
self.assertEqual(("foo/base,key1=val1/other/elements", {}),
564
split_segment_parameters("foo/base,key1=val1/other/elements"))
565
self.assertEqual(("foo/base,key1=val1/other/elements",
566
{"key2": "val2"}), split_segment_parameters(
567
"foo/base,key1=val1/other/elements,key2=val2"))
568
# TODO: Check full URLs as well as relative references
570
def test_win32_strip_local_trailing_slash(self):
571
strip = urlutils._win32_strip_local_trailing_slash
572
self.assertEqual('file://', strip('file://'))
573
self.assertEqual('file:///', strip('file:///'))
574
self.assertEqual('file:///C', strip('file:///C'))
575
self.assertEqual('file:///C:', strip('file:///C:'))
576
self.assertEqual('file:///d|', strip('file:///d|'))
577
self.assertEqual('file:///C:/', strip('file:///C:/'))
578
self.assertEqual('file:///C:/a', strip('file:///C:/a/'))
580
def test_strip_trailing_slash(self):
581
sts = urlutils.strip_trailing_slash
582
if sys.platform == 'win32':
583
self.assertEqual('file:///C|/', sts('file:///C|/'))
584
self.assertEqual('file:///C:/foo', sts('file:///C:/foo'))
585
self.assertEqual('file:///C|/foo', sts('file:///C|/foo/'))
587
self.assertEqual('file:///', sts('file:///'))
588
self.assertEqual('file:///foo', sts('file:///foo'))
589
self.assertEqual('file:///foo', sts('file:///foo/'))
591
self.assertEqual('http://host/', sts('http://host/'))
592
self.assertEqual('http://host/foo', sts('http://host/foo'))
593
self.assertEqual('http://host/foo', sts('http://host/foo/'))
595
# No need to fail just because the slash is missing
596
self.assertEqual('http://host', sts('http://host'))
597
# TODO: jam 20060502 Should this raise InvalidURL?
598
self.assertEqual('file://', sts('file://'))
600
self.assertEqual('random+scheme://user:pass@ahost:port/path',
601
sts('random+scheme://user:pass@ahost:port/path'))
602
self.assertEqual('random+scheme://user:pass@ahost:port/path',
603
sts('random+scheme://user:pass@ahost:port/path/'))
604
self.assertEqual('random+scheme://user:pass@ahost:port/',
605
sts('random+scheme://user:pass@ahost:port/'))
607
# Make sure relative paths work too
608
self.assertEqual('path/to/foo', sts('path/to/foo'))
609
self.assertEqual('path/to/foo', sts('path/to/foo/'))
610
self.assertEqual('../to/foo', sts('../to/foo/'))
611
self.assertEqual('path/../foo', sts('path/../foo/'))
613
def test_unescape_for_display_utf8(self):
614
# Test that URLs are converted to nice unicode strings for display
615
def test(expected, url, encoding='utf-8'):
616
disp_url = urlutils.unescape_for_display(url, encoding=encoding)
617
self.assertIsInstance(disp_url, text_type)
618
self.assertEqual(expected, disp_url)
620
test('http://foo', 'http://foo')
621
if sys.platform == 'win32':
622
test('C:/foo/path', 'file:///C|/foo/path')
623
test('C:/foo/path', 'file:///C:/foo/path')
625
test('/foo/path', 'file:///foo/path')
627
test('http://foo/%2Fbaz', 'http://foo/%2Fbaz')
628
test(u'http://host/r\xe4ksm\xf6rg\xe5s',
629
'http://host/r%C3%A4ksm%C3%B6rg%C3%A5s')
631
# Make sure special escaped characters stay escaped
632
test(u'http://host/%3B%2F%3F%3A%40%26%3D%2B%24%2C%23',
633
'http://host/%3B%2F%3F%3A%40%26%3D%2B%24%2C%23')
635
# Can we handle sections that don't have utf-8 encoding?
636
test(u'http://host/%EE%EE%EE/r\xe4ksm\xf6rg\xe5s',
637
'http://host/%EE%EE%EE/r%C3%A4ksm%C3%B6rg%C3%A5s')
639
# Test encoding into output that can handle some characters
640
test(u'http://host/%EE%EE%EE/r\xe4ksm\xf6rg\xe5s',
641
'http://host/%EE%EE%EE/r%C3%A4ksm%C3%B6rg%C3%A5s',
642
encoding='iso-8859-1')
644
# This one can be encoded into utf8
645
test(u'http://host/\u062c\u0648\u062c\u0648',
646
'http://host/%d8%ac%d9%88%d8%ac%d9%88',
649
# This can't be put into 8859-1 and so stays as escapes
650
test(u'http://host/%d8%ac%d9%88%d8%ac%d9%88',
651
'http://host/%d8%ac%d9%88%d8%ac%d9%88',
652
encoding='iso-8859-1')
654
def test_escape(self):
655
self.assertEqual('%25', urlutils.escape('%'))
656
self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
657
self.assertFalse(isinstance(urlutils.escape(u'\xe5'), text_type))
659
def test_escape_tildes(self):
660
self.assertEqual('~foo', urlutils.escape('~foo'))
662
def test_unescape(self):
663
self.assertEqual('%', urlutils.unescape('%25'))
664
self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
667
self.assertRaises(urlutils.InvalidURL, urlutils.unescape, u'\xe5')
668
self.assertRaises((TypeError, urlutils.InvalidURL), urlutils.unescape, b'\xe5')
670
self.assertRaises(urlutils.InvalidURL, urlutils.unescape, '%E5')
672
self.assertEqual('\xe5', urlutils.unescape('%C3%A5'))
674
def test_escape_unescape(self):
675
self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
676
self.assertEqual('%', urlutils.unescape(urlutils.escape('%')))
678
def test_relative_url(self):
679
def test(expected, base, other):
680
result = urlutils.relative_url(base, other)
681
self.assertEqual(expected, result)
683
test('a', 'http://host/', 'http://host/a')
684
test('http://entirely/different', 'sftp://host/branch',
685
'http://entirely/different')
686
test('../person/feature', 'http://host/branch/mainline',
687
'http://host/branch/person/feature')
688
test('..', 'http://host/branch', 'http://host/')
689
test('http://host2/branch', 'http://host1/branch', 'http://host2/branch')
690
test('.', 'http://host1/branch', 'http://host1/branch')
691
test('../../../branch/2b', 'file:///home/jelmer/foo/bar/2b',
692
'file:///home/jelmer/branch/2b')
693
test('../../branch/2b', 'sftp://host/home/jelmer/bar/2b',
694
'sftp://host/home/jelmer/branch/2b')
695
test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
696
'http://host/home/jelmer/branch/feature/%2b')
697
test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
698
'http://host/home/jelmer/branch/feature/2b')
699
# relative_url should preserve a trailing slash
700
test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
701
'http://host/home/jelmer/branch/feature/2b/')
702
test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b',
703
'http://host/home/jelmer/branch/feature/2b/')
705
# TODO: treat http://host as http://host/
706
# relative_url is typically called from a branch.base or
707
# transport.base which always ends with a /
708
#test('a', 'http://host', 'http://host/a')
709
test('http://host/a', 'http://host', 'http://host/a')
710
#test('.', 'http://host', 'http://host/')
711
test('http://host/', 'http://host', 'http://host/')
712
#test('.', 'http://host/', 'http://host')
713
test('http://host', 'http://host/', 'http://host')
715
# On Windows file:///C:/path/to and file:///D:/other/path
716
# should not use relative url over the non-existent '/' directory.
717
if sys.platform == 'win32':
719
test('../../other/path',
720
'file:///C:/path/to', 'file:///C:/other/path')
721
#~next two tests is failed, i.e. urlutils.relative_url expects
722
#~to see normalized file URLs?
723
#~test('../../other/path',
724
#~ 'file:///C:/path/to', 'file:///c:/other/path')
725
#~test('../../other/path',
726
#~ 'file:///C:/path/to', 'file:///C|/other/path')
728
# check UNC paths too
729
test('../../other/path',
730
'file://HOST/base/path/to', 'file://HOST/base/other/path')
731
# on different drives
732
test('file:///D:/other/path',
733
'file:///C:/path/to', 'file:///D:/other/path')
734
# TODO: strictly saying in UNC path //HOST/base is full analog
735
# of drive letter for hard disk, and this situation is also
736
# should be exception from rules. [bialix 20071221]
739
class TestCwdToURL(TestCaseInTempDir):
740
"""Test that local_path_to_url works based on the cwd"""
743
# This test will fail if getcwd is not ascii
747
url = urlutils.local_path_to_url('.')
748
self.assertEndsWith(url, '/mytest')
750
def test_non_ascii(self):
754
raise TestSkipped('cannot create unicode directory')
758
# On Mac OSX this directory is actually:
759
# u'/dode\u0301' => '/dode\xcc\x81
760
# but we should normalize it back to
761
# u'/dod\xe9' => '/dod\xc3\xa9'
762
url = urlutils.local_path_to_url('.')
763
self.assertEndsWith(url, '/dod%C3%A9')
766
class TestDeriveToLocation(TestCase):
767
"""Test that the mapping of FROM_LOCATION to TO_LOCATION works."""
769
def test_to_locations_derived_from_paths(self):
770
derive = urlutils.derive_to_location
771
self.assertEqual("bar", derive("bar"))
772
self.assertEqual("bar", derive("../bar"))
773
self.assertEqual("bar", derive("/foo/bar"))
774
self.assertEqual("bar", derive("c:/foo/bar"))
775
self.assertEqual("bar", derive("c:bar"))
777
def test_to_locations_derived_from_urls(self):
778
derive = urlutils.derive_to_location
779
self.assertEqual("bar", derive("http://foo/bar"))
780
self.assertEqual("bar", derive("bzr+ssh://foo/bar"))
781
self.assertEqual("foo-bar", derive("lp:foo-bar"))
784
class TestRebaseURL(TestCase):
785
"""Test the behavior of rebase_url."""
787
def test_non_relative(self):
788
result = urlutils.rebase_url('file://foo', 'file://foo',
790
self.assertEqual('file://foo', result)
791
result = urlutils.rebase_url('/foo', 'file://foo',
793
self.assertEqual('/foo', result)
795
def test_different_ports(self):
796
e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
797
'foo', 'http://bar:80', 'http://bar:81')
798
self.assertEqual(str(e), "URLs differ by more than path:"
799
" 'http://bar:80' and 'http://bar:81'")
801
def test_different_hosts(self):
802
e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
803
'foo', 'http://bar', 'http://baz')
804
self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
807
def test_different_protocol(self):
808
e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
809
'foo', 'http://bar', 'ftp://bar')
810
self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
813
def test_rebase_success(self):
814
self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',
816
self.assertEqual('qux/bar', urlutils.rebase_url('bar',
817
'http://baz/qux', 'http://baz/'))
818
self.assertEqual('.', urlutils.rebase_url('foo',
819
'http://bar/', 'http://bar/foo/'))
820
self.assertEqual('qux/bar', urlutils.rebase_url('../bar',
821
'http://baz/qux/foo', 'http://baz/'))
823
def test_determine_relative_path(self):
824
self.assertEqual('../../baz/bar',
825
urlutils.determine_relative_path(
826
'/qux/quxx', '/baz/bar'))
827
self.assertEqual('..',
828
urlutils.determine_relative_path(
830
self.assertEqual('baz',
831
urlutils.determine_relative_path(
833
self.assertEqual('.', urlutils.determine_relative_path(
837
class TestParseURL(TestCase):
839
def test_parse_simple(self):
840
parsed = urlutils.parse_url('http://example.com:80/one')
841
self.assertEqual(('http', None, None, 'example.com', 80, '/one'),
845
parsed = urlutils.parse_url('http://[1:2:3::40]/one')
846
self.assertEqual(('http', None, None, '1:2:3::40', None, '/one'),
849
def test_ipv6_port(self):
850
parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
851
self.assertEqual(('http', None, None, '1:2:3::40', 80, '/one'),
855
class TestURL(TestCase):
857
def test_parse_simple(self):
858
parsed = urlutils.URL.from_string('http://example.com:80/one')
859
self.assertEqual('http', parsed.scheme)
860
self.assertIs(None, parsed.user)
861
self.assertIs(None, parsed.password)
862
self.assertEqual('example.com', parsed.host)
863
self.assertEqual(80, parsed.port)
864
self.assertEqual('/one', parsed.path)
867
parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
868
self.assertEqual('http', parsed.scheme)
869
self.assertIs(None, parsed.port)
870
self.assertIs(None, parsed.user)
871
self.assertIs(None, parsed.password)
872
self.assertEqual('1:2:3::40', parsed.host)
873
self.assertEqual('/one', parsed.path)
875
def test_ipv6_port(self):
876
parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
877
self.assertEqual('http', parsed.scheme)
878
self.assertEqual('1:2:3::40', parsed.host)
879
self.assertIs(None, parsed.user)
880
self.assertIs(None, parsed.password)
881
self.assertEqual(80, parsed.port)
882
self.assertEqual('/one', parsed.path)
884
def test_quoted(self):
885
parsed = urlutils.URL.from_string(
886
'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
887
self.assertEqual(parsed.quoted_host, 'ex%41mple.com')
888
self.assertEqual(parsed.host, 'exAmple.com')
889
self.assertEqual(parsed.port, 2222)
890
self.assertEqual(parsed.quoted_user, 'ro%62ey')
891
self.assertEqual(parsed.user, 'robey')
892
self.assertEqual(parsed.quoted_password, 'h%40t')
893
self.assertEqual(parsed.password, 'h@t')
894
self.assertEqual(parsed.path, '/path')
897
parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
898
parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
899
self.assertEqual(parsed1, parsed2)
900
self.assertEqual(parsed1, parsed1)
901
parsed2.path = '/two'
902
self.assertNotEqual(parsed1, parsed2)
905
parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
907
"<URL('http', None, None, '1:2:3::40', 80, '/one')>",
911
parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
912
self.assertEqual('http://[1:2:3::40]:80/one', str(parsed))
914
def test__combine_paths(self):
915
combine = urlutils.URL._combine_paths
916
self.assertEqual('/home/sarah/project/foo',
917
combine('/home/sarah', 'project/foo'))
918
self.assertEqual('/etc',
919
combine('/home/sarah', '../../etc'))
920
self.assertEqual('/etc',
921
combine('/home/sarah', '../../../etc'))
922
self.assertEqual('/etc',
923
combine('/home/sarah', '/etc'))
925
def test_clone(self):
926
url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
927
url1 = url.clone("two")
928
self.assertEqual("/one/two", url1.path)
929
url2 = url.clone("/two")
930
self.assertEqual("/two", url2.path)
932
self.assertIsNot(url, url3)
933
self.assertEqual(url, url3)
936
class TestFileRelpath(TestCase):
938
# GZ 2011-11-18: A way to override all path handling functions to one
939
# platform or another for testing would be nice.
941
def _with_posix_paths(self):
942
self.overrideAttr(urlutils, "local_path_from_url",
943
urlutils._posix_local_path_from_url)
944
self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH", len("file:///"))
945
self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
946
self.overrideAttr(osutils, "abspath", osutils._posix_abspath)
947
self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
948
self.overrideAttr(osutils, "pathjoin", osutils.posixpath.join)
949
self.overrideAttr(osutils, "split", osutils.posixpath.split)
950
self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 1)
952
def _with_win32_paths(self):
953
self.overrideAttr(urlutils, "local_path_from_url",
954
urlutils._win32_local_path_from_url)
955
self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH",
956
urlutils.WIN32_MIN_ABS_FILEURL_LENGTH)
957
self.overrideAttr(osutils, "abspath", osutils._win32_abspath)
958
self.overrideAttr(osutils, "normpath", osutils._win32_normpath)
959
self.overrideAttr(osutils, "pathjoin", osutils._win32_pathjoin)
960
self.overrideAttr(osutils, "split", osutils.ntpath.split)
961
self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 3)
963
def test_same_url_posix(self):
964
self._with_posix_paths()
966
urlutils.file_relpath("file:///a", "file:///a"))
968
urlutils.file_relpath("file:///a", "file:///a/"))
970
urlutils.file_relpath("file:///a/", "file:///a"))
972
def test_same_url_win32(self):
973
self._with_win32_paths()
975
urlutils.file_relpath("file:///A:/", "file:///A:/"))
977
urlutils.file_relpath("file:///A|/", "file:///A:/"))
979
urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
981
urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
983
urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
985
def test_child_posix(self):
986
self._with_posix_paths()
987
self.assertEqual("b",
988
urlutils.file_relpath("file:///a", "file:///a/b"))
989
self.assertEqual("b",
990
urlutils.file_relpath("file:///a/", "file:///a/b"))
991
self.assertEqual("b/c",
992
urlutils.file_relpath("file:///a", "file:///a/b/c"))
994
def test_child_win32(self):
995
self._with_win32_paths()
996
self.assertEqual("b",
997
urlutils.file_relpath("file:///A:/", "file:///A:/b"))
998
self.assertEqual("b",
999
urlutils.file_relpath("file:///A|/", "file:///A:/b"))
1000
self.assertEqual("c",
1001
urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
1002
self.assertEqual("c",
1003
urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
1004
self.assertEqual("c/d",
1005
urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
1007
def test_sibling_posix(self):
1008
self._with_posix_paths()
1009
self.assertRaises(PathNotChild,
1010
urlutils.file_relpath, "file:///a/b", "file:///a/c")
1011
self.assertRaises(PathNotChild,
1012
urlutils.file_relpath, "file:///a/b/", "file:///a/c")
1013
self.assertRaises(PathNotChild,
1014
urlutils.file_relpath, "file:///a/b/", "file:///a/c/")
1016
def test_sibling_win32(self):
1017
self._with_win32_paths()
1018
self.assertRaises(PathNotChild,
1019
urlutils.file_relpath, "file:///A:/b", "file:///A:/c")
1020
self.assertRaises(PathNotChild,
1021
urlutils.file_relpath, "file:///A:/b/", "file:///A:/c")
1022
self.assertRaises(PathNotChild,
1023
urlutils.file_relpath, "file:///A:/b/", "file:///A:/c/")
1025
def test_parent_posix(self):
1026
self._with_posix_paths()
1027
self.assertRaises(PathNotChild,
1028
urlutils.file_relpath, "file:///a/b", "file:///a")
1029
self.assertRaises(PathNotChild,
1030
urlutils.file_relpath, "file:///a/b", "file:///a/")
1032
def test_parent_win32(self):
1033
self._with_win32_paths()
1034
self.assertRaises(PathNotChild,
1035
urlutils.file_relpath, "file:///A:/b", "file:///A:/")
1036
self.assertRaises(PathNotChild,
1037
urlutils.file_relpath, "file:///A:/b/c", "file:///A:/b")
1040
class QuoteTests(TestCase):
1042
def test_quote(self):
1043
self.assertEqual('abc%20def', urlutils.quote('abc def'))
1044
self.assertEqual('abc%2Fdef', urlutils.quote('abc/def', safe=''))
1045
self.assertEqual('abc/def', urlutils.quote('abc/def', safe='/'))
1047
def test_quote_tildes(self):
1048
self.assertEqual('%7Efoo', urlutils.quote('~foo'))
1049
self.assertEqual('~foo', urlutils.quote('~foo', safe='/~'))
1051
def test_unquote(self):
1052
self.assertEqual('%', urlutils.unquote('%25'))
1053
self.assertEqual('\xc3\xa5', urlutils.unquote('%C3%A5'))
1054
self.assertEqual(u"\xe5", urlutils.unquote(u'\xe5'))
added
removed
breezy/tests/test_urlutils.py
