~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-02-01 13:53:24 UTC
  • mfrom: (4990.1.2 rm-obsolete)
  • Revision ID: pqm@pqm.ubuntu.com-20100201135324-cuhuolr97guf5xjp
(Jelmer) Remove obsolete (and broken) biobench and history2revfiles
        tools.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
#
 
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.
 
7
#
 
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.
 
12
#
 
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
 
16
 
 
17
"""Tests for the urlutils wrapper."""
 
18
 
 
19
import os
 
20
import sys
 
21
 
 
22
from bzrlib import osutils, urlutils, win32utils
 
23
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
 
24
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
 
25
 
 
26
 
 
27
class TestUrlToPath(TestCase):
 
28
 
 
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:/'))
 
38
        else:
 
39
            self.assertEqual('foo', basename('file:///foo'))
 
40
            self.assertEqual('', basename('file:///'))
 
41
 
 
42
        self.assertEqual('foo', basename('http://host/path/to/foo'))
 
43
        self.assertEqual('foo', basename('http://host/path/to/foo/'))
 
44
        self.assertEqual('',
 
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'))
 
50
 
 
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/'))
 
54
 
 
55
        # relative paths
 
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'))
 
62
 
 
63
    def test_normalize_url_files(self):
 
64
        # Test that local paths are properly normalized
 
65
        normalize_url = urlutils.normalize_url
 
66
 
 
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:'):]
 
72
            else:
 
73
                url = url[len('file://'):]
 
74
 
 
75
            self.assertEndsWith(url, expected)
 
76
 
 
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')
 
80
 
 
81
        # Local paths are assumed to *not* be escaped at all
 
82
        try:
 
83
            u'uni/\xb5'.encode(osutils.get_user_encoding())
 
84
        except UnicodeError:
 
85
            # locale cannot handle unicode
 
86
            pass
 
87
        else:
 
88
            norm_file('uni/%C2%B5', u'uni/\xb5')
 
89
 
 
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', "' ;/?:@&=+$,#")
 
96
 
 
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
 
101
 
 
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$'))
 
111
 
 
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'))
 
115
 
 
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'))
 
121
 
 
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/ ')
 
126
 
 
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
 
131
 
 
132
            :param scheme_and_path: The (scheme, path) that should be matched
 
133
                can be None, to indicate it should not match
 
134
            """
 
135
            m = urlutils._url_scheme_re.match(url)
 
136
            if scheme_and_path is None:
 
137
                self.assertEqual(None, m)
 
138
            else:
 
139
                self.assertEqual(scheme_and_path[0], m.group('scheme'))
 
140
                self.assertEqual(scheme_and_path[1], m.group('path'))
 
141
 
 
142
        # Local paths
 
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)
 
147
 
 
148
        # Real URLS
 
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'))
 
155
 
 
156
        # Weird stuff
 
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'))
 
163
 
 
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|/'))
 
171
        else:
 
172
            self.assertEqual('file:///', dirname('file:///foo'))
 
173
            self.assertEqual('file:///', dirname('file:///'))
 
174
 
 
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'))
 
183
 
 
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/'))
 
190
 
 
191
        # relative paths
 
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'))
 
198
 
 
199
    def test_join(self):
 
200
        def test(expected, *args):
 
201
            joined = urlutils.join(*args)
 
202
            self.assertEqual(expected, joined)
 
203
 
 
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')
 
213
 
 
214
        # Absolute paths
 
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/')
 
222
 
 
223
        # From a base path
 
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', '')
 
228
 
 
229
        # Invalid joinings
 
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,
 
235
                'http://foo', '/..')
 
236
        # Joining from a path explicitly under the root.
 
237
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
238
                'http://foo/a', '../../b')
 
239
 
 
240
    def test_joinpath(self):
 
241
        def test(expected, *args):
 
242
            joined = urlutils.joinpath(*args)
 
243
            self.assertEqual(expected, joined)
 
244
 
 
245
        # Test a single element
 
246
        test('foo', 'foo')
 
247
 
 
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')
 
254
 
 
255
        # Test joining to an absolute path
 
256
        test('/foo', '/foo')
 
257
        test('/foo', '/foo', '.')
 
258
        test('/foo/bar', '/foo', 'bar')
 
259
        test('/', '/foo', '..')
 
260
 
 
261
        # Test joining with an absolute path
 
262
        test('/bar', 'foo', '/bar')
 
263
 
 
264
        # Test joining to a path with a trailing slash
 
265
        test('foo/bar', 'foo/', 'bar')
 
266
 
 
267
        # Invalid joinings
 
268
        # Cannot go above root
 
269
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
 
270
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
 
271
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
 
272
 
 
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)
 
277
        else:
 
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)
 
280
 
 
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'))
 
285
 
 
286
        try:
 
287
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
 
288
        except UnicodeError:
 
289
            raise TestSkipped("local encoding cannot handle unicode")
 
290
 
 
291
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
292
        self.assertFalse(isinstance(result, unicode))
 
293
 
 
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'))
 
304
 
 
305
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
 
306
        self.assertRaises(
 
307
            InvalidURL, from_url,
 
308
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
 
309
 
 
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'))
 
322
 
 
323
        self.assertEqual('file:///', to_url('/'))
 
324
 
 
325
        try:
 
326
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
 
327
        except UnicodeError:
 
328
            raise TestSkipped("local encoding cannot handle unicode")
 
329
 
 
330
        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
331
        self.assertFalse(isinstance(result, unicode))
 
332
 
 
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'))
 
339
 
 
340
        try:
 
341
            result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')
 
342
        except UnicodeError:
 
343
            raise TestSkipped("local encoding cannot handle unicode")
 
344
 
 
345
        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
346
        self.assertFalse(isinstance(result, unicode))
 
347
 
 
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:///'))
 
357
 
 
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')
 
361
 
 
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')
 
373
 
 
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')
 
379
 
 
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:/'))
 
387
        else:
 
388
            self.assertEqual(('file:///', 'foo'), split('file:///foo'))
 
389
            self.assertEqual(('file:///', ''), split('file:///'))
 
390
 
 
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'))
 
399
 
 
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/'))
 
406
 
 
407
        # relative paths
 
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'))
 
414
 
 
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/'))
 
424
 
 
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/'))
 
431
        else:
 
432
            self.assertEqual('file:///', sts('file:///'))
 
433
            self.assertEqual('file:///foo', sts('file:///foo'))
 
434
            self.assertEqual('file:///foo', sts('file:///foo/'))
 
435
 
 
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/'))
 
439
 
 
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://'))
 
444
 
 
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/'))
 
451
 
 
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/'))
 
457
 
 
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)
 
464
 
 
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')
 
469
        else:
 
470
            test('/foo/path', 'file:///foo/path')
 
471
 
 
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')
 
475
 
 
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')
 
479
 
 
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')
 
483
 
 
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')
 
488
 
 
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',
 
492
             encoding='utf-8')
 
493
 
 
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')
 
498
 
 
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))
 
503
 
 
504
    def test_escape_tildes(self):
 
505
        self.assertEqual('~foo', urlutils.escape('~foo'))
 
506
 
 
507
    def test_unescape(self):
 
508
        self.assertEqual('%', urlutils.unescape('%25'))
 
509
        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
 
510
 
 
511
        self.assertRaises(InvalidURL, urlutils.unescape, u'\xe5')
 
512
        self.assertRaises(InvalidURL, urlutils.unescape, '\xe5')
 
513
        self.assertRaises(InvalidURL, urlutils.unescape, '%E5')
 
514
 
 
515
    def test_escape_unescape(self):
 
516
        self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
 
517
        self.assertEqual('%', urlutils.unescape(urlutils.escape('%')))
 
518
 
 
519
    def test_relative_url(self):
 
520
        def test(expected, base, other):
 
521
            result = urlutils.relative_url(base, other)
 
522
            self.assertEqual(expected, result)
 
523
 
 
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/')
 
545
 
 
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')
 
555
 
 
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':
 
559
            # on the same drive
 
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')
 
568
 
 
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]
 
578
 
 
579
 
 
580
class TestCwdToURL(TestCaseInTempDir):
 
581
    """Test that local_path_to_url works base on the cwd"""
 
582
 
 
583
    def test_dot(self):
 
584
        # This test will fail if getcwd is not ascii
 
585
        os.mkdir('mytest')
 
586
        os.chdir('mytest')
 
587
 
 
588
        url = urlutils.local_path_to_url('.')
 
589
        self.assertEndsWith(url, '/mytest')
 
590
 
 
591
    def test_non_ascii(self):
 
592
        if win32utils.winver == 'Windows 98':
 
593
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
 
594
 
 
595
        try:
 
596
            os.mkdir(u'dod\xe9')
 
597
        except UnicodeError:
 
598
            raise TestSkipped('cannot create unicode directory')
 
599
 
 
600
        os.chdir(u'dod\xe9')
 
601
 
 
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')
 
608
 
 
609
 
 
610
class TestDeriveToLocation(TestCase):
 
611
    """Test that the mapping of FROM_LOCATION to TO_LOCATION works."""
 
612
 
 
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"))
 
620
 
 
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"))
 
626
 
 
627
 
 
628
class TestRebaseURL(TestCase):
 
629
    """Test the behavior of rebase_url."""
 
630
 
 
631
    def test_non_relative(self):
 
632
        result = urlutils.rebase_url('file://foo', 'file://foo',
 
633
                                     'file://foo/bar')
 
634
        self.assertEqual('file://foo', result)
 
635
        result = urlutils.rebase_url('/foo', 'file://foo',
 
636
                                     'file://foo/bar')
 
637
        self.assertEqual('/foo', result)
 
638
 
 
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'")
 
644
 
 
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'"
 
649
                         " and 'http://baz'")
 
650
 
 
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'"
 
655
                         " and 'ftp://bar'")
 
656
 
 
657
    def test_rebase_success(self):
 
658
        self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',
 
659
                         'http://baz/qux'))
 
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/'))
 
666
 
 
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(
 
673
                         '/bar/baz', '/bar'))
 
674
        self.assertEqual('baz',
 
675
                         urlutils.determine_relative_path(
 
676
                         '/bar', '/bar/baz'))
 
677
        self.assertEqual('.', urlutils.determine_relative_path(
 
678
                         '/bar', '/bar'))
 
679
 
 
680
 
 
681
class TestParseURL(TestCase):
 
682
 
 
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'))