1
# Copyright (C) 2005 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 bzrlib import osutils, urlutils, win32utils
23
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
24
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
27
class TestUrlToPath(TestCase):
29
def test_basename(self):
30
# bzrlib.urlutils.basename
31
# Test bzrlib.urlutils.split()
32
basename = urlutils.basename
33
if sys.platform == 'win32':
34
self.assertRaises(InvalidURL, basename, 'file:///path/to/foo')
35
self.assertEqual('foo', basename('file:///C|/foo'))
36
self.assertEqual('foo', basename('file:///C:/foo'))
37
self.assertEqual('', basename('file:///C:/'))
39
self.assertEqual('foo', basename('file:///foo'))
40
self.assertEqual('', basename('file:///'))
42
self.assertEqual('foo', basename('http://host/path/to/foo'))
43
self.assertEqual('foo', basename('http://host/path/to/foo/'))
45
basename('http://host/path/to/foo/', exclude_trailing_slash=False))
46
self.assertEqual('path', basename('http://host/path'))
47
self.assertEqual('', basename('http://host/'))
48
self.assertEqual('', basename('http://host'))
49
self.assertEqual('path', basename('http:///nohost/path'))
51
self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path'))
52
self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path/'))
53
self.assertEqual('', basename('random+scheme://user:pass@ahost:port/'))
56
self.assertEqual('foo', basename('path/to/foo'))
57
self.assertEqual('foo', basename('path/to/foo/'))
58
self.assertEqual('', basename('path/to/foo/',
59
exclude_trailing_slash=False))
60
self.assertEqual('foo', basename('path/../foo'))
61
self.assertEqual('foo', basename('../path/foo'))
63
def test_normalize_url_files(self):
64
# Test that local paths are properly normalized
65
normalize_url = urlutils.normalize_url
67
def norm_file(expected, path):
68
url = normalize_url(path)
69
self.assertStartsWith(url, 'file:///')
70
if sys.platform == 'win32':
71
url = url[len('file:///C:'):]
73
url = url[len('file://'):]
75
self.assertEndsWith(url, expected)
77
norm_file('path/to/foo', 'path/to/foo')
78
norm_file('/path/to/foo', '/path/to/foo')
79
norm_file('path/to/foo', '../path/to/foo')
81
# Local paths are assumed to *not* be escaped at all
83
u'uni/\xb5'.encode(osutils.get_user_encoding())
85
# locale cannot handle unicode
88
norm_file('uni/%C2%B5', u'uni/\xb5')
90
norm_file('uni/%25C2%25B5', u'uni/%C2%B5')
91
norm_file('uni/%20b', u'uni/ b')
92
# All the crazy characters get escaped in local paths => file:/// urls
93
# The ' ' character must not be at the end, because on win32
94
# it gets stripped off by ntpath.abspath
95
norm_file('%27%20%3B/%3F%3A%40%26%3D%2B%24%2C%23', "' ;/?:@&=+$,#")
97
def test_normalize_url_hybrid(self):
98
# Anything with a scheme:// should be treated as a hybrid url
99
# which changes what characters get escaped.
100
normalize_url = urlutils.normalize_url
102
eq = self.assertEqual
103
eq('file:///foo/', normalize_url(u'file:///foo/'))
104
eq('file:///foo/%20', normalize_url(u'file:///foo/ '))
105
eq('file:///foo/%20', normalize_url(u'file:///foo/%20'))
106
# Don't escape reserved characters
107
eq('file:///ab_c.d-e/%f:?g&h=i+j;k,L#M$',
108
normalize_url('file:///ab_c.d-e/%f:?g&h=i+j;k,L#M$'))
109
eq('http://ab_c.d-e/%f:?g&h=i+j;k,L#M$',
110
normalize_url('http://ab_c.d-e/%f:?g&h=i+j;k,L#M$'))
112
# Escape unicode characters, but not already escaped chars
113
eq('http://host/ab/%C2%B5/%C2%B5',
114
normalize_url(u'http://host/ab/%C2%B5/\xb5'))
116
# Unescape characters that don't need to be escaped
117
eq('http://host/~bob%2525-._',
118
normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
119
eq('http://host/~bob%2525-._',
120
normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
122
# Normalize verifies URLs when they are not unicode
123
# (indicating they did not come from the user)
124
self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
125
self.assertRaises(InvalidURL, normalize_url, 'http://host/ ')
127
def test_url_scheme_re(self):
128
# Test paths that may be URLs
129
def test_one(url, scheme_and_path):
130
"""Assert that _url_scheme_re correctly matches
132
:param scheme_and_path: The (scheme, path) that should be matched
133
can be None, to indicate it should not match
135
m = urlutils._url_scheme_re.match(url)
136
if scheme_and_path is None:
137
self.assertEqual(None, m)
139
self.assertEqual(scheme_and_path[0], m.group('scheme'))
140
self.assertEqual(scheme_and_path[1], m.group('path'))
143
test_one('/path', None)
144
test_one('C:/path', None)
145
test_one('../path/to/foo', None)
146
test_one(u'../path/to/fo\xe5', None)
149
test_one('http://host/path/', ('http', 'host/path/'))
150
test_one('sftp://host/path/to/foo', ('sftp', 'host/path/to/foo'))
151
test_one('file:///usr/bin', ('file', '/usr/bin'))
152
test_one('file:///C:/Windows', ('file', '/C:/Windows'))
153
test_one('file:///C|/Windows', ('file', '/C|/Windows'))
154
test_one(u'readonly+sftp://host/path/\xe5', ('readonly+sftp', u'host/path/\xe5'))
157
# Can't have slashes or colons in the scheme
158
test_one('/path/to/://foo', None)
159
test_one('path:path://foo', None)
160
# Must have more than one character for scheme
161
test_one('C://foo', None)
162
test_one('ab://foo', ('ab', 'foo'))
164
def test_dirname(self):
165
# Test bzrlib.urlutils.dirname()
166
dirname = urlutils.dirname
167
if sys.platform == 'win32':
168
self.assertRaises(InvalidURL, dirname, 'file:///path/to/foo')
169
self.assertEqual('file:///C|/', dirname('file:///C|/foo'))
170
self.assertEqual('file:///C|/', dirname('file:///C|/'))
172
self.assertEqual('file:///', dirname('file:///foo'))
173
self.assertEqual('file:///', dirname('file:///'))
175
self.assertEqual('http://host/path/to', dirname('http://host/path/to/foo'))
176
self.assertEqual('http://host/path/to', dirname('http://host/path/to/foo/'))
177
self.assertEqual('http://host/path/to/foo',
178
dirname('http://host/path/to/foo/', exclude_trailing_slash=False))
179
self.assertEqual('http://host/', dirname('http://host/path'))
180
self.assertEqual('http://host/', dirname('http://host/'))
181
self.assertEqual('http://host', dirname('http://host'))
182
self.assertEqual('http:///nohost', dirname('http:///nohost/path'))
184
self.assertEqual('random+scheme://user:pass@ahost:port/',
185
dirname('random+scheme://user:pass@ahost:port/path'))
186
self.assertEqual('random+scheme://user:pass@ahost:port/',
187
dirname('random+scheme://user:pass@ahost:port/path/'))
188
self.assertEqual('random+scheme://user:pass@ahost:port/',
189
dirname('random+scheme://user:pass@ahost:port/'))
192
self.assertEqual('path/to', dirname('path/to/foo'))
193
self.assertEqual('path/to', dirname('path/to/foo/'))
194
self.assertEqual('path/to/foo',
195
dirname('path/to/foo/', exclude_trailing_slash=False))
196
self.assertEqual('path/..', dirname('path/../foo'))
197
self.assertEqual('../path', dirname('../path/foo'))
200
def test(expected, *args):
201
joined = urlutils.join(*args)
202
self.assertEqual(expected, joined)
204
# Test relative path joining
205
test('foo', 'foo') # relative fragment with nothing is preserved.
206
test('foo/bar', 'foo', 'bar')
207
test('http://foo/bar', 'http://foo', 'bar')
208
test('http://foo/bar', 'http://foo', '.', 'bar')
209
test('http://foo/baz', 'http://foo', 'bar', '../baz')
210
test('http://foo/bar/baz', 'http://foo', 'bar/baz')
211
test('http://foo/baz', 'http://foo', 'bar/../baz')
212
test('http://foo/baz', 'http://foo/bar/', '../baz')
215
test('http://foo', 'http://foo') # abs url with nothing is preserved.
216
test('http://bar', 'http://foo', 'http://bar')
217
test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')
218
test('file:///bar', 'foo', 'file:///bar')
219
test('http://bar/', 'http://foo', 'http://bar/')
220
test('http://bar/a', 'http://foo', 'http://bar/a')
221
test('http://bar/a/', 'http://foo', 'http://bar/a/')
224
test('file:///foo', 'file:///', 'foo')
225
test('file:///bar/foo', 'file:///bar/', 'foo')
226
test('http://host/foo', 'http://host/', 'foo')
227
test('http://host/', 'http://host', '')
230
# Cannot go above root
231
# Implicitly at root:
232
self.assertRaises(InvalidURLJoin, urlutils.join,
233
'http://foo', '../baz')
234
self.assertRaises(InvalidURLJoin, urlutils.join,
236
# Joining from a path explicitly under the root.
237
self.assertRaises(InvalidURLJoin, urlutils.join,
238
'http://foo/a', '../../b')
240
def test_joinpath(self):
241
def test(expected, *args):
242
joined = urlutils.joinpath(*args)
243
self.assertEqual(expected, joined)
245
# Test a single element
248
# Test relative path joining
249
test('foo/bar', 'foo', 'bar')
250
test('foo/bar', 'foo', '.', 'bar')
251
test('foo/baz', 'foo', 'bar', '../baz')
252
test('foo/bar/baz', 'foo', 'bar/baz')
253
test('foo/baz', 'foo', 'bar/../baz')
255
# Test joining to an absolute path
257
test('/foo', '/foo', '.')
258
test('/foo/bar', '/foo', 'bar')
259
test('/', '/foo', '..')
261
# Test joining with an absolute path
262
test('/bar', 'foo', '/bar')
264
# Test joining to a path with a trailing slash
265
test('foo/bar', 'foo/', 'bar')
268
# Cannot go above root
269
self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
270
self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
271
self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
273
def test_function_type(self):
274
if sys.platform == 'win32':
275
self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
276
self.assertEqual(urlutils._win32_local_path_from_url, urlutils.local_path_from_url)
278
self.assertEqual(urlutils._posix_local_path_to_url, urlutils.local_path_to_url)
279
self.assertEqual(urlutils._posix_local_path_from_url, urlutils.local_path_from_url)
281
def test_posix_local_path_to_url(self):
282
to_url = urlutils._posix_local_path_to_url
283
self.assertEqual('file:///path/to/foo',
284
to_url('/path/to/foo'))
287
result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
289
raise TestSkipped("local encoding cannot handle unicode")
291
self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
292
self.assertFalse(isinstance(result, unicode))
294
def test_posix_local_path_from_url(self):
295
from_url = urlutils._posix_local_path_from_url
296
self.assertEqual('/path/to/foo',
297
from_url('file:///path/to/foo'))
298
self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
299
from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
300
self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
301
from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
302
self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
303
from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
305
self.assertRaises(InvalidURL, from_url, '/path/to/foo')
307
InvalidURL, from_url,
308
'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
310
def test_win32_local_path_to_url(self):
311
to_url = urlutils._win32_local_path_to_url
312
self.assertEqual('file:///C:/path/to/foo',
313
to_url('C:/path/to/foo'))
314
# BOGUS: on win32, ntpath.abspath will strip trailing
315
# whitespace, so this will always fail
316
# Though under linux, it fakes abspath support
317
# and thus will succeed
318
# self.assertEqual('file:///C:/path/to/foo%20',
319
# to_url('C:/path/to/foo '))
320
self.assertEqual('file:///C:/path/to/f%20oo',
321
to_url('C:/path/to/f oo'))
323
self.assertEqual('file:///', to_url('/'))
326
result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
328
raise TestSkipped("local encoding cannot handle unicode")
330
self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
331
self.assertFalse(isinstance(result, unicode))
333
def test_win32_unc_path_to_url(self):
334
to_url = urlutils._win32_local_path_to_url
335
self.assertEqual('file://HOST/path',
336
to_url(r'\\HOST\path'))
337
self.assertEqual('file://HOST/path',
338
to_url('//HOST/path'))
341
result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')
343
raise TestSkipped("local encoding cannot handle unicode")
345
self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
346
self.assertFalse(isinstance(result, unicode))
348
def test_win32_local_path_from_url(self):
349
from_url = urlutils._win32_local_path_from_url
350
self.assertEqual('C:/path/to/foo',
351
from_url('file:///C|/path/to/foo'))
352
self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
353
from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
354
self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
355
from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
356
self.assertEqual('/', from_url('file:///'))
358
self.assertRaises(InvalidURL, from_url, '/path/to/foo')
359
# Not a valid _win32 url, no drive letter
360
self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
362
def test_win32_unc_path_from_url(self):
363
from_url = urlutils._win32_local_path_from_url
364
self.assertEqual('//HOST/path', from_url('file://HOST/path'))
365
# despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
366
# we want to use only 2 slashes
367
# Firefox understand only 5 slashes in URL, but it's ugly
368
self.assertRaises(InvalidURL, from_url, 'file:////HOST/path')
369
self.assertRaises(InvalidURL, from_url, 'file://///HOST/path')
370
self.assertRaises(InvalidURL, from_url, 'file://////HOST/path')
371
# check for file://C:/ instead of file:///C:/
372
self.assertRaises(InvalidURL, from_url, 'file://C:/path')
374
def test_win32_extract_drive_letter(self):
375
extract = urlutils._win32_extract_drive_letter
376
self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
377
self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
378
self.assertRaises(InvalidURL, extract, 'file://', '/path')
380
def test_split(self):
381
# Test bzrlib.urlutils.split()
382
split = urlutils.split
383
if sys.platform == 'win32':
384
self.assertRaises(InvalidURL, split, 'file:///path/to/foo')
385
self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))
386
self.assertEqual(('file:///C:/', ''), split('file:///C:/'))
388
self.assertEqual(('file:///', 'foo'), split('file:///foo'))
389
self.assertEqual(('file:///', ''), split('file:///'))
391
self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo'))
392
self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo/'))
393
self.assertEqual(('http://host/path/to/foo', ''),
394
split('http://host/path/to/foo/', exclude_trailing_slash=False))
395
self.assertEqual(('http://host/', 'path'), split('http://host/path'))
396
self.assertEqual(('http://host/', ''), split('http://host/'))
397
self.assertEqual(('http://host', ''), split('http://host'))
398
self.assertEqual(('http:///nohost', 'path'), split('http:///nohost/path'))
400
self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
401
split('random+scheme://user:pass@ahost:port/path'))
402
self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
403
split('random+scheme://user:pass@ahost:port/path/'))
404
self.assertEqual(('random+scheme://user:pass@ahost:port/', ''),
405
split('random+scheme://user:pass@ahost:port/'))
408
self.assertEqual(('path/to', 'foo'), split('path/to/foo'))
409
self.assertEqual(('path/to', 'foo'), split('path/to/foo/'))
410
self.assertEqual(('path/to/foo', ''),
411
split('path/to/foo/', exclude_trailing_slash=False))
412
self.assertEqual(('path/..', 'foo'), split('path/../foo'))
413
self.assertEqual(('../path', 'foo'), split('../path/foo'))
415
def test_win32_strip_local_trailing_slash(self):
416
strip = urlutils._win32_strip_local_trailing_slash
417
self.assertEqual('file://', strip('file://'))
418
self.assertEqual('file:///', strip('file:///'))
419
self.assertEqual('file:///C', strip('file:///C'))
420
self.assertEqual('file:///C:', strip('file:///C:'))
421
self.assertEqual('file:///d|', strip('file:///d|'))
422
self.assertEqual('file:///C:/', strip('file:///C:/'))
423
self.assertEqual('file:///C:/a', strip('file:///C:/a/'))
425
def test_strip_trailing_slash(self):
426
sts = urlutils.strip_trailing_slash
427
if sys.platform == 'win32':
428
self.assertEqual('file:///C|/', sts('file:///C|/'))
429
self.assertEqual('file:///C:/foo', sts('file:///C:/foo'))
430
self.assertEqual('file:///C|/foo', sts('file:///C|/foo/'))
432
self.assertEqual('file:///', sts('file:///'))
433
self.assertEqual('file:///foo', sts('file:///foo'))
434
self.assertEqual('file:///foo', sts('file:///foo/'))
436
self.assertEqual('http://host/', sts('http://host/'))
437
self.assertEqual('http://host/foo', sts('http://host/foo'))
438
self.assertEqual('http://host/foo', sts('http://host/foo/'))
440
# No need to fail just because the slash is missing
441
self.assertEqual('http://host', sts('http://host'))
442
# TODO: jam 20060502 Should this raise InvalidURL?
443
self.assertEqual('file://', sts('file://'))
445
self.assertEqual('random+scheme://user:pass@ahost:port/path',
446
sts('random+scheme://user:pass@ahost:port/path'))
447
self.assertEqual('random+scheme://user:pass@ahost:port/path',
448
sts('random+scheme://user:pass@ahost:port/path/'))
449
self.assertEqual('random+scheme://user:pass@ahost:port/',
450
sts('random+scheme://user:pass@ahost:port/'))
452
# Make sure relative paths work too
453
self.assertEqual('path/to/foo', sts('path/to/foo'))
454
self.assertEqual('path/to/foo', sts('path/to/foo/'))
455
self.assertEqual('../to/foo', sts('../to/foo/'))
456
self.assertEqual('path/../foo', sts('path/../foo/'))
458
def test_unescape_for_display_utf8(self):
459
# Test that URLs are converted to nice unicode strings for display
460
def test(expected, url, encoding='utf-8'):
461
disp_url = urlutils.unescape_for_display(url, encoding=encoding)
462
self.assertIsInstance(disp_url, unicode)
463
self.assertEqual(expected, disp_url)
465
test('http://foo', 'http://foo')
466
if sys.platform == 'win32':
467
test('C:/foo/path', 'file:///C|/foo/path')
468
test('C:/foo/path', 'file:///C:/foo/path')
470
test('/foo/path', 'file:///foo/path')
472
test('http://foo/%2Fbaz', 'http://foo/%2Fbaz')
473
test(u'http://host/r\xe4ksm\xf6rg\xe5s',
474
'http://host/r%C3%A4ksm%C3%B6rg%C3%A5s')
476
# Make sure special escaped characters stay escaped
477
test(u'http://host/%3B%2F%3F%3A%40%26%3D%2B%24%2C%23',
478
'http://host/%3B%2F%3F%3A%40%26%3D%2B%24%2C%23')
480
# Can we handle sections that don't have utf-8 encoding?
481
test(u'http://host/%EE%EE%EE/r\xe4ksm\xf6rg\xe5s',
482
'http://host/%EE%EE%EE/r%C3%A4ksm%C3%B6rg%C3%A5s')
484
# Test encoding into output that can handle some characters
485
test(u'http://host/%EE%EE%EE/r\xe4ksm\xf6rg\xe5s',
486
'http://host/%EE%EE%EE/r%C3%A4ksm%C3%B6rg%C3%A5s',
487
encoding='iso-8859-1')
489
# This one can be encoded into utf8
490
test(u'http://host/\u062c\u0648\u062c\u0648',
491
'http://host/%d8%ac%d9%88%d8%ac%d9%88',
494
# This can't be put into 8859-1 and so stays as escapes
495
test(u'http://host/%d8%ac%d9%88%d8%ac%d9%88',
496
'http://host/%d8%ac%d9%88%d8%ac%d9%88',
497
encoding='iso-8859-1')
499
def test_escape(self):
500
self.assertEqual('%25', urlutils.escape('%'))
501
self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
502
self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
504
def test_escape_tildes(self):
505
self.assertEqual('~foo', urlutils.escape('~foo'))
507
def test_unescape(self):
508
self.assertEqual('%', urlutils.unescape('%25'))
509
self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
511
self.assertRaises(InvalidURL, urlutils.unescape, u'\xe5')
512
self.assertRaises(InvalidURL, urlutils.unescape, '\xe5')
513
self.assertRaises(InvalidURL, urlutils.unescape, '%E5')
515
def test_escape_unescape(self):
516
self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
517
self.assertEqual('%', urlutils.unescape(urlutils.escape('%')))
519
def test_relative_url(self):
520
def test(expected, base, other):
521
result = urlutils.relative_url(base, other)
522
self.assertEqual(expected, result)
524
test('a', 'http://host/', 'http://host/a')
525
test('http://entirely/different', 'sftp://host/branch',
526
'http://entirely/different')
527
test('../person/feature', 'http://host/branch/mainline',
528
'http://host/branch/person/feature')
529
test('..', 'http://host/branch', 'http://host/')
530
test('http://host2/branch', 'http://host1/branch', 'http://host2/branch')
531
test('.', 'http://host1/branch', 'http://host1/branch')
532
test('../../../branch/2b', 'file:///home/jelmer/foo/bar/2b',
533
'file:///home/jelmer/branch/2b')
534
test('../../branch/2b', 'sftp://host/home/jelmer/bar/2b',
535
'sftp://host/home/jelmer/branch/2b')
536
test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
537
'http://host/home/jelmer/branch/feature/%2b')
538
test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
539
'http://host/home/jelmer/branch/feature/2b')
540
# relative_url should preserve a trailing slash
541
test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
542
'http://host/home/jelmer/branch/feature/2b/')
543
test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b',
544
'http://host/home/jelmer/branch/feature/2b/')
546
# TODO: treat http://host as http://host/
547
# relative_url is typically called from a branch.base or
548
# transport.base which always ends with a /
549
#test('a', 'http://host', 'http://host/a')
550
test('http://host/a', 'http://host', 'http://host/a')
551
#test('.', 'http://host', 'http://host/')
552
test('http://host/', 'http://host', 'http://host/')
553
#test('.', 'http://host/', 'http://host')
554
test('http://host', 'http://host/', 'http://host')
556
# On Windows file:///C:/path/to and file:///D:/other/path
557
# should not use relative url over the non-existent '/' directory.
558
if sys.platform == 'win32':
560
test('../../other/path',
561
'file:///C:/path/to', 'file:///C:/other/path')
562
#~next two tests is failed, i.e. urlutils.relative_url expects
563
#~to see normalized file URLs?
564
#~test('../../other/path',
565
#~ 'file:///C:/path/to', 'file:///c:/other/path')
566
#~test('../../other/path',
567
#~ 'file:///C:/path/to', 'file:///C|/other/path')
569
# check UNC paths too
570
test('../../other/path',
571
'file://HOST/base/path/to', 'file://HOST/base/other/path')
572
# on different drives
573
test('file:///D:/other/path',
574
'file:///C:/path/to', 'file:///D:/other/path')
575
# TODO: strictly saying in UNC path //HOST/base is full analog
576
# of drive letter for hard disk, and this situation is also
577
# should be exception from rules. [bialix 20071221]
580
class TestCwdToURL(TestCaseInTempDir):
581
"""Test that local_path_to_url works base on the cwd"""
584
# This test will fail if getcwd is not ascii
588
url = urlutils.local_path_to_url('.')
589
self.assertEndsWith(url, '/mytest')
591
def test_non_ascii(self):
592
if win32utils.winver == 'Windows 98':
593
raise TestSkipped('Windows 98 cannot handle unicode filenames')
598
raise TestSkipped('cannot create unicode directory')
602
# On Mac OSX this directory is actually:
603
# u'/dode\u0301' => '/dode\xcc\x81
604
# but we should normalize it back to
605
# u'/dod\xe9' => '/dod\xc3\xa9'
606
url = urlutils.local_path_to_url('.')
607
self.assertEndsWith(url, '/dod%C3%A9')
610
class TestDeriveToLocation(TestCase):
611
"""Test that the mapping of FROM_LOCATION to TO_LOCATION works."""
613
def test_to_locations_derived_from_paths(self):
614
derive = urlutils.derive_to_location
615
self.assertEqual("bar", derive("bar"))
616
self.assertEqual("bar", derive("../bar"))
617
self.assertEqual("bar", derive("/foo/bar"))
618
self.assertEqual("bar", derive("c:/foo/bar"))
619
self.assertEqual("bar", derive("c:bar"))
621
def test_to_locations_derived_from_urls(self):
622
derive = urlutils.derive_to_location
623
self.assertEqual("bar", derive("http://foo/bar"))
624
self.assertEqual("bar", derive("bzr+ssh://foo/bar"))
625
self.assertEqual("foo-bar", derive("lp:foo-bar"))
628
class TestRebaseURL(TestCase):
629
"""Test the behavior of rebase_url."""
631
def test_non_relative(self):
632
result = urlutils.rebase_url('file://foo', 'file://foo',
634
self.assertEqual('file://foo', result)
635
result = urlutils.rebase_url('/foo', 'file://foo',
637
self.assertEqual('/foo', result)
639
def test_different_ports(self):
640
e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
641
'foo', 'http://bar:80', 'http://bar:81')
642
self.assertEqual(str(e), "URLs differ by more than path:"
643
" 'http://bar:80' and 'http://bar:81'")
645
def test_different_hosts(self):
646
e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
647
'foo', 'http://bar', 'http://baz')
648
self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
651
def test_different_protocol(self):
652
e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
653
'foo', 'http://bar', 'ftp://bar')
654
self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
657
def test_rebase_success(self):
658
self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',
660
self.assertEqual('qux/bar', urlutils.rebase_url('bar',
661
'http://baz/qux', 'http://baz/'))
662
self.assertEqual('.', urlutils.rebase_url('foo',
663
'http://bar/', 'http://bar/foo/'))
664
self.assertEqual('qux/bar', urlutils.rebase_url('../bar',
665
'http://baz/qux/foo', 'http://baz/'))
667
def test_determine_relative_path(self):
668
self.assertEqual('../../baz/bar',
669
urlutils.determine_relative_path(
670
'/qux/quxx', '/baz/bar'))
671
self.assertEqual('..',
672
urlutils.determine_relative_path(
674
self.assertEqual('baz',
675
urlutils.determine_relative_path(
677
self.assertEqual('.', urlutils.determine_relative_path(
681
class TestParseURL(TestCase):
683
def test_parse_url(self):
684
self.assertEqual(urlutils.parse_url('http://example.com:80/one'),
685
('http', None, None, 'example.com', 80, '/one'))
686
self.assertEqual(urlutils.parse_url('http://[1:2:3::40]/one'),
687
('http', None, None, '1:2:3::40', None, '/one'))
688
self.assertEqual(urlutils.parse_url('http://[1:2:3::40]:80/one'),
689
('http', None, None, '1:2:3::40', 80, '/one'))
added
removed
bzrlib/tests/test_urlutils.py
