/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

  • Committer: John Arbash Meinel
  • Date: 2006-05-10 19:59:55 UTC
  • mfrom: (1704 +trunk)
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: john@arbash-meinel.com-20060510195955-df080afb1daa3a96
[merge] bzr.dev 1704

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005 by Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for the urlutils wrapper."""
18
18
 
19
19
import os
20
20
import sys
21
21
 
22
 
from bzrlib import osutils, urlutils, win32utils
23
 
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
24
 
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
 
22
import bzrlib
 
23
from bzrlib.errors import InvalidURL
 
24
import bzrlib.urlutils as urlutils
 
25
from bzrlib.tests import TestCaseInTempDir, TestCase
25
26
 
26
27
 
27
28
class TestUrlToPath(TestCase):
28
 
 
 
29
    
29
30
    def test_basename(self):
30
31
        # bzrlib.urlutils.basename
31
32
        # Test bzrlib.urlutils.split()
33
34
        if sys.platform == 'win32':
34
35
            self.assertRaises(InvalidURL, basename, 'file:///path/to/foo')
35
36
            self.assertEqual('foo', basename('file:///C|/foo'))
36
 
            self.assertEqual('foo', basename('file:///C:/foo'))
37
 
            self.assertEqual('', basename('file:///C:/'))
 
37
            self.assertEqual('', basename('file:///C|/'))
38
38
        else:
39
39
            self.assertEqual('foo', basename('file:///foo'))
40
40
            self.assertEqual('', basename('file:///'))
72
72
            else:
73
73
                url = url[len('file://'):]
74
74
 
75
 
            self.assertEndsWith(url, expected)
 
75
            self.assertEndsWith(path, expected)
76
76
 
77
77
        norm_file('path/to/foo', 'path/to/foo')
78
78
        norm_file('/path/to/foo', '/path/to/foo')
79
79
        norm_file('path/to/foo', '../path/to/foo')
80
80
 
81
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
 
 
 
82
        norm_file('uni/%C2%B5', u'uni/\xb5')
90
83
        norm_file('uni/%25C2%25B5', u'uni/%C2%B5')
91
84
        norm_file('uni/%20b', u'uni/ b')
92
85
        # 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', "' ;/?:@&=+$,#")
 
86
        norm_file('%27%3B/%3F%3A%40%26%3D%2B%24%2C%23%20', "';/?:@&=+$,#")
96
87
 
97
88
    def test_normalize_url_hybrid(self):
98
89
        # Anything with a scheme:// should be treated as a hybrid url
113
104
        eq('http://host/ab/%C2%B5/%C2%B5',
114
105
            normalize_url(u'http://host/ab/%C2%B5/\xb5'))
115
106
 
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
107
        # Normalize verifies URLs when they are not unicode
123
108
        # (indicating they did not come from the user)
124
109
        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
196
181
        self.assertEqual('path/..', dirname('path/../foo'))
197
182
        self.assertEqual('../path', dirname('../path/foo'))
198
183
 
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
184
    def test_function_type(self):
274
185
        if sys.platform == 'win32':
275
186
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
282
193
        to_url = urlutils._posix_local_path_to_url
283
194
        self.assertEqual('file:///path/to/foo',
284
195
            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))
 
196
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s',
 
197
            to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s'))
293
198
 
294
199
    def test_posix_local_path_from_url(self):
295
200
        from_url = urlutils._posix_local_path_from_url
299
204
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
300
205
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
301
206
            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
207
 
305
208
        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
209
 
310
210
    def test_win32_local_path_to_url(self):
311
211
        to_url = urlutils._win32_local_path_to_url
312
 
        self.assertEqual('file:///C:/path/to/foo',
 
212
        self.assertEqual('file:///C|/path/to/foo',
313
213
            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))
 
214
        self.assertEqual('file:///D|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s',
 
215
            to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s'))
347
216
 
348
217
    def test_win32_local_path_from_url(self):
349
218
        from_url = urlutils._win32_local_path_from_url
352
221
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
353
222
            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
354
223
        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:///'))
 
224
            from_url('file:///d|/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
357
225
 
358
226
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
359
227
        # Not a valid _win32 url, no drive letter
360
228
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
361
229
 
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
230
    def test_split(self):
381
231
        # Test bzrlib.urlutils.split()
382
232
        split = urlutils.split
383
233
        if sys.platform == 'win32':
384
234
            self.assertRaises(InvalidURL, split, 'file:///path/to/foo')
385
235
            self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))
386
 
            self.assertEqual(('file:///C:/', ''), split('file:///C:/'))
 
236
            self.assertEqual(('file:///C|/', ''), split('file:///C|/'))
387
237
        else:
388
238
            self.assertEqual(('file:///', 'foo'), split('file:///foo'))
389
239
            self.assertEqual(('file:///', ''), split('file:///'))
412
262
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
413
263
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
414
264
 
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
265
    def test_strip_trailing_slash(self):
426
266
        sts = urlutils.strip_trailing_slash
427
267
        if sys.platform == 'win32':
428
268
            self.assertEqual('file:///C|/', sts('file:///C|/'))
429
 
            self.assertEqual('file:///C:/foo', sts('file:///C:/foo'))
 
269
            self.assertEqual('file:///C|/foo', sts('file:///C|/foo'))
430
270
            self.assertEqual('file:///C|/foo', sts('file:///C|/foo/'))
431
271
        else:
432
272
            self.assertEqual('file:///', sts('file:///'))
455
295
        self.assertEqual('../to/foo', sts('../to/foo/'))
456
296
        self.assertEqual('path/../foo', sts('path/../foo/'))
457
297
 
458
 
    def test_unescape_for_display_utf8(self):
 
298
    def test_unescape_for_display(self):
459
299
        # 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')
 
300
        disp = urlutils.unescape_for_display
 
301
        eq = self.assertEqual
 
302
        eq('http://foo', disp('http://foo'))
466
303
        if sys.platform == 'win32':
467
 
            test('C:/foo/path', 'file:///C|/foo/path')
468
 
            test('C:/foo/path', 'file:///C:/foo/path')
 
304
            eq('C:/foo/path', disp('file:///C|foo/path'))
469
305
        else:
470
 
            test('/foo/path', 'file:///foo/path')
 
306
            eq('/foo/path', disp('file:///foo/path'))
471
307
 
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')
 
308
        eq('http://foo/%2Fbaz', disp('http://foo/%2Fbaz'))
 
309
        eq(u'http://host/r\xe4ksm\xf6rg\xe5s', disp('http://host/r%C3%A4ksm%C3%B6rg%C3%A5s'))
475
310
 
476
311
        # 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')
 
312
        eq(u'http://host/%3B%2F%3F%3A%40%26%3D%2B%24%2C%23',
 
313
            disp('http://host/%3B%2F%3F%3A%40%26%3D%2B%24%2C%23'))
479
314
 
480
315
        # 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')
 
316
        eq(u'http://host/%EE%EE%EE/r\xe4ksm\xf6rg\xe5s',
 
317
            disp('http://host/%EE%EE%EE/r%C3%A4ksm%C3%B6rg%C3%A5s'))
498
318
 
499
319
    def test_escape(self):
500
320
        self.assertEqual('%25', urlutils.escape('%'))
501
321
        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
322
 
507
323
    def test_unescape(self):
508
324
        self.assertEqual('%', urlutils.unescape('%25'))
516
332
        self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
517
333
        self.assertEqual('%', urlutils.unescape(urlutils.escape('%')))
518
334
 
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'))