← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

  • Committer: John Arbash Meinel
  • Date: 2008-05-28 23:20:33 UTC
  • mto: This revision was merged to the branch mainline in revision 3458.
  • Revision ID: john@arbash-meinel.com-20080528232033-cx3l3yg845udklps
Bring back always in the form of 'override'.
Change the functions so that they are compatible with the released
definition, and just allow callers to supply override=False
if they want the new behavior.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005 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
17
17
"""Tests for the urlutils wrapper."""
18
18
 
19
19
import os
 
20
import re
20
21
import sys
21
22
 
 
23
from bzrlib import osutils, urlutils, win32utils
22
24
import bzrlib
23
25
from bzrlib.errors import InvalidURL, InvalidURLJoin
24
 
import bzrlib.urlutils as urlutils
25
26
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
26
27
 
27
28
 
91
92
        norm_file('uni/%25C2%25B5', u'uni/%C2%B5')
92
93
        norm_file('uni/%20b', u'uni/ b')
93
94
        # All the crazy characters get escaped in local paths => file:/// urls
94
 
        norm_file('%27%3B/%3F%3A%40%26%3D%2B%24%2C%23%20', "';/?:@&=+$,# ")
 
95
        # The ' ' character must not be at the end, because on win32
 
96
        # it gets stripped off by ntpath.abspath
 
97
        norm_file('%27%20%3B/%3F%3A%40%26%3D%2B%24%2C%23', "' ;/?:@&=+$,#")
95
98
 
96
99
    def test_normalize_url_hybrid(self):
97
100
        # Anything with a scheme:// should be treated as a hybrid url
112
115
        eq('http://host/ab/%C2%B5/%C2%B5',
113
116
            normalize_url(u'http://host/ab/%C2%B5/\xb5'))
114
117
 
 
118
        # Unescape characters that don't need to be escaped
 
119
        eq('http://host/~bob%2525-._',
 
120
                normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
 
121
        eq('http://host/~bob%2525-._',
 
122
                normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
 
123
 
115
124
        # Normalize verifies URLs when they are not unicode
116
125
        # (indicating they did not come from the user)
117
126
        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
194
203
            joined = urlutils.join(*args)
195
204
            self.assertEqual(expected, joined)
196
205
 
197
 
        # Test a single element
198
 
        test('foo', 'foo')
199
 
 
200
206
        # Test relative path joining
 
207
        test('foo', 'foo') # relative fragment with nothing is preserved.
201
208
        test('foo/bar', 'foo', 'bar')
202
209
        test('http://foo/bar', 'http://foo', 'bar')
203
210
        test('http://foo/bar', 'http://foo', '.', 'bar')
204
211
        test('http://foo/baz', 'http://foo', 'bar', '../baz')
205
212
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
206
213
        test('http://foo/baz', 'http://foo', 'bar/../baz')
 
214
        test('http://foo/baz', 'http://foo/bar/', '../baz')
207
215
 
208
216
        # Absolute paths
 
217
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
209
218
        test('http://bar', 'http://foo', 'http://bar')
210
219
        test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')
211
220
        test('file:///bar', 'foo', 'file:///bar')
 
221
        test('http://bar/', 'http://foo', 'http://bar/')
 
222
        test('http://bar/a', 'http://foo', 'http://bar/a')
 
223
        test('http://bar/a/', 'http://foo', 'http://bar/a/')
 
224
 
 
225
        # From a base path
 
226
        test('file:///foo', 'file:///', 'foo')
 
227
        test('file:///bar/foo', 'file:///bar/', 'foo')
 
228
        test('http://host/foo', 'http://host/', 'foo')
 
229
        test('http://host/', 'http://host', '')
212
230
        
213
231
        # Invalid joinings
214
232
        # Cannot go above root
 
233
        # Implicitly at root:
215
234
        self.assertRaises(InvalidURLJoin, urlutils.join,
216
235
                'http://foo', '../baz')
 
236
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
237
                'http://foo', '/..')
 
238
        # Joining from a path explicitly under the root.
 
239
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
240
                'http://foo/a', '../../b')
 
241
 
 
242
    def test_joinpath(self):
 
243
        def test(expected, *args):
 
244
            joined = urlutils.joinpath(*args)
 
245
            self.assertEqual(expected, joined)
 
246
 
 
247
        # Test a single element
 
248
        test('foo', 'foo')
 
249
 
 
250
        # Test relative path joining
 
251
        test('foo/bar', 'foo', 'bar')
 
252
        test('foo/bar', 'foo', '.', 'bar')
 
253
        test('foo/baz', 'foo', 'bar', '../baz')
 
254
        test('foo/bar/baz', 'foo', 'bar/baz')
 
255
        test('foo/baz', 'foo', 'bar/../baz')
 
256
 
 
257
        # Test joining to an absolute path
 
258
        test('/foo', '/foo')
 
259
        test('/foo', '/foo', '.')
 
260
        test('/foo/bar', '/foo', 'bar')
 
261
        test('/', '/foo', '..')
 
262
 
 
263
        # Test joining with an absolute path
 
264
        test('/bar', 'foo', '/bar')
 
265
 
 
266
        # Test joining to a path with a trailing slash
 
267
        test('foo/bar', 'foo/', 'bar')
 
268
        
 
269
        # Invalid joinings
 
270
        # Cannot go above root
 
271
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
 
272
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
 
273
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
217
274
 
218
275
    def test_function_type(self):
219
276
        if sys.platform == 'win32':
234
291
            raise TestSkipped("local encoding cannot handle unicode")
235
292
 
236
293
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
294
        self.assertFalse(isinstance(result, unicode))
237
295
 
238
296
    def test_posix_local_path_from_url(self):
239
297
        from_url = urlutils._posix_local_path_from_url
250
308
        to_url = urlutils._win32_local_path_to_url
251
309
        self.assertEqual('file:///C:/path/to/foo',
252
310
            to_url('C:/path/to/foo'))
 
311
        # BOGUS: on win32, ntpath.abspath will strip trailing
 
312
        #       whitespace, so this will always fail
 
313
        #       Though under linux, it fakes abspath support
 
314
        #       and thus will succeed
 
315
        # self.assertEqual('file:///C:/path/to/foo%20',
 
316
        #     to_url('C:/path/to/foo '))
 
317
        self.assertEqual('file:///C:/path/to/f%20oo',
 
318
            to_url('C:/path/to/f oo'))
253
319
 
254
320
        try:
255
321
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
257
323
            raise TestSkipped("local encoding cannot handle unicode")
258
324
 
259
325
        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
326
        self.assertFalse(isinstance(result, unicode))
 
327
 
 
328
    def test_win32_unc_path_to_url(self):
 
329
        to_url = urlutils._win32_local_path_to_url
 
330
        self.assertEqual('file://HOST/path',
 
331
            to_url(r'\\HOST\path'))
 
332
        self.assertEqual('file://HOST/path',
 
333
            to_url('//HOST/path'))
 
334
 
 
335
        try:
 
336
            result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')
 
337
        except UnicodeError:
 
338
            raise TestSkipped("local encoding cannot handle unicode")
 
339
 
 
340
        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
341
        self.assertFalse(isinstance(result, unicode))
260
342
 
261
343
    def test_win32_local_path_from_url(self):
262
344
        from_url = urlutils._win32_local_path_from_url
271
353
        # Not a valid _win32 url, no drive letter
272
354
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
273
355
 
 
356
    def test_win32_unc_path_from_url(self):
 
357
        from_url = urlutils._win32_local_path_from_url
 
358
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
 
359
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
 
360
        # we want to use only 2 slashes
 
361
        # Firefox understand only 5 slashes in URL, but it's ugly
 
362
        self.assertRaises(InvalidURL, from_url, 'file:////HOST/path')
 
363
        self.assertRaises(InvalidURL, from_url, 'file://///HOST/path')
 
364
        self.assertRaises(InvalidURL, from_url, 'file://////HOST/path')
 
365
        # check for file://C:/ instead of file:///C:/
 
366
        self.assertRaises(InvalidURL, from_url, 'file://C:/path')
 
367
 
 
368
    def test_win32_extract_drive_letter(self):
 
369
        extract = urlutils._win32_extract_drive_letter
 
370
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
 
371
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
 
372
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
 
373
 
274
374
    def test_split(self):
275
375
        # Test bzrlib.urlutils.split()
276
376
        split = urlutils.split
306
406
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
307
407
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
308
408
 
 
409
    def test_win32_strip_local_trailing_slash(self):
 
410
        strip = urlutils._win32_strip_local_trailing_slash
 
411
        self.assertEqual('file://', strip('file://'))
 
412
        self.assertEqual('file:///', strip('file:///'))
 
413
        self.assertEqual('file:///C', strip('file:///C'))
 
414
        self.assertEqual('file:///C:', strip('file:///C:'))
 
415
        self.assertEqual('file:///d|', strip('file:///d|'))
 
416
        self.assertEqual('file:///C:/', strip('file:///C:/'))
 
417
        self.assertEqual('file:///C:/a', strip('file:///C:/a/'))
 
418
 
309
419
    def test_strip_trailing_slash(self):
310
420
        sts = urlutils.strip_trailing_slash
311
421
        if sys.platform == 'win32':
383
493
    def test_escape(self):
384
494
        self.assertEqual('%25', urlutils.escape('%'))
385
495
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
 
496
        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
386
497
 
387
498
    def test_unescape(self):
388
499
        self.assertEqual('%', urlutils.unescape('%25'))
432
543
        test('http://host/', 'http://host', 'http://host/')
433
544
        #test('.', 'http://host/', 'http://host')
434
545
        test('http://host', 'http://host/', 'http://host')
 
546
 
 
547
        # On Windows file:///C:/path/to and file:///D:/other/path
 
548
        # should not use relative url over the non-existent '/' directory.
 
549
        if sys.platform == 'win32':
 
550
            # on the same drive
 
551
            test('../../other/path',
 
552
                'file:///C:/path/to', 'file:///C:/other/path')
 
553
            #~next two tests is failed, i.e. urlutils.relative_url expects
 
554
            #~to see normalized file URLs?
 
555
            #~test('../../other/path',
 
556
            #~    'file:///C:/path/to', 'file:///c:/other/path')
 
557
            #~test('../../other/path',
 
558
            #~    'file:///C:/path/to', 'file:///C|/other/path')
 
559
 
 
560
            # check UNC paths too
 
561
            test('../../other/path',
 
562
                'file://HOST/base/path/to', 'file://HOST/base/other/path')
 
563
            # on different drives
 
564
            test('file:///D:/other/path',
 
565
                'file:///C:/path/to', 'file:///D:/other/path')
 
566
            # TODO: strictly saying in UNC path //HOST/base is full analog
 
567
            # of drive letter for hard disk, and this situation is also
 
568
            # should be exception from rules. [bialix 20071221]
 
569
 
 
570
 
 
571
class TestCwdToURL(TestCaseInTempDir):
 
572
    """Test that local_path_to_url works base on the cwd"""
 
573
 
 
574
    def test_dot(self):
 
575
        # This test will fail if getcwd is not ascii
 
576
        os.mkdir('mytest')
 
577
        os.chdir('mytest')
 
578
 
 
579
        url = urlutils.local_path_to_url('.')
 
580
        self.assertEndsWith(url, '/mytest')
 
581
 
 
582
    def test_non_ascii(self):
 
583
        if win32utils.winver == 'Windows 98':
 
584
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
 
585
 
 
586
        try:
 
587
            os.mkdir(u'dod\xe9')
 
588
        except UnicodeError:
 
589
            raise TestSkipped('cannot create unicode directory')
 
590
 
 
591
        os.chdir(u'dod\xe9')
 
592
 
 
593
        # On Mac OSX this directory is actually: 
 
594
        #   u'/dode\u0301' => '/dode\xcc\x81
 
595
        # but we should normalize it back to 
 
596
        #   u'/dod\xe9' => '/dod\xc3\xa9'
 
597
        url = urlutils.local_path_to_url('.')
 
598
        self.assertEndsWith(url, '/dod%C3%A9')
 
599
 
 
600
 
 
601
class TestDeriveToLocation(TestCase):
 
602
    """Test that the mapping of FROM_LOCATION to TO_LOCATION works."""
 
603
 
 
604
    def test_to_locations_derived_from_paths(self):
 
605
        derive = urlutils.derive_to_location
 
606
        self.assertEqual("bar", derive("bar"))
 
607
        self.assertEqual("bar", derive("../bar"))
 
608
        self.assertEqual("bar", derive("/foo/bar"))
 
609
        self.assertEqual("bar", derive("c:/foo/bar"))
 
610
        self.assertEqual("bar", derive("c:bar"))
 
611
 
 
612
    def test_to_locations_derived_from_urls(self):
 
613
        derive = urlutils.derive_to_location
 
614
        self.assertEqual("bar", derive("http://foo/bar"))
 
615
        self.assertEqual("bar", derive("bzr+ssh://foo/bar"))
 
616
        self.assertEqual("foo-bar", derive("lp:foo-bar"))