← 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: Aaron Bentley
  • Date: 2006-06-21 14:30:57 UTC
  • mfrom: (1801.1.1 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 1803.
  • Revision ID: abentley@panoramicfeedback.com-20060621143057-776e4b8d707e430e
Install benchmarks. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2005 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
 
import re
21
20
import sys
22
21
 
23
 
from bzrlib import osutils, urlutils, win32utils
24
 
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
 
22
import bzrlib
 
23
from bzrlib.errors import InvalidURL, InvalidURLJoin
 
24
import bzrlib.urlutils as urlutils
25
25
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
26
26
 
27
27
 
28
28
class TestUrlToPath(TestCase):
29
 
 
 
29
    
30
30
    def test_basename(self):
31
31
        # bzrlib.urlutils.basename
32
32
        # Test bzrlib.urlutils.split()
81
81
 
82
82
        # Local paths are assumed to *not* be escaped at all
83
83
        try:
84
 
            u'uni/\xb5'.encode(osutils.get_user_encoding())
 
84
            u'uni/\xb5'.encode(bzrlib.user_encoding)
85
85
        except UnicodeError:
86
 
            # locale cannot handle unicode
 
86
            # locale cannot handle unicode 
87
87
            pass
88
88
        else:
89
89
            norm_file('uni/%C2%B5', u'uni/\xb5')
114
114
        eq('http://host/ab/%C2%B5/%C2%B5',
115
115
            normalize_url(u'http://host/ab/%C2%B5/\xb5'))
116
116
 
117
 
        # Unescape characters that don't need to be escaped
118
 
        eq('http://host/~bob%2525-._',
119
 
                normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
120
 
        eq('http://host/~bob%2525-._',
121
 
                normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
122
 
 
123
117
        # Normalize verifies URLs when they are not unicode
124
118
        # (indicating they did not come from the user)
125
119
        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
202
196
            joined = urlutils.join(*args)
203
197
            self.assertEqual(expected, joined)
204
198
 
 
199
        # Test a single element
 
200
        test('foo', 'foo')
 
201
 
205
202
        # Test relative path joining
206
 
        test('foo', 'foo') # relative fragment with nothing is preserved.
207
203
        test('foo/bar', 'foo', 'bar')
208
204
        test('http://foo/bar', 'http://foo', 'bar')
209
205
        test('http://foo/bar', 'http://foo', '.', 'bar')
210
206
        test('http://foo/baz', 'http://foo', 'bar', '../baz')
211
207
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
212
208
        test('http://foo/baz', 'http://foo', 'bar/../baz')
213
 
        test('http://foo/baz', 'http://foo/bar/', '../baz')
214
209
 
215
210
        # Absolute paths
216
 
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
217
211
        test('http://bar', 'http://foo', 'http://bar')
218
212
        test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')
219
213
        test('file:///bar', 'foo', 'file:///bar')
220
 
        test('http://bar/', 'http://foo', 'http://bar/')
221
 
        test('http://bar/a', 'http://foo', 'http://bar/a')
222
 
        test('http://bar/a/', 'http://foo', 'http://bar/a/')
223
214
 
224
215
        # From a base path
225
216
        test('file:///foo', 'file:///', 'foo')
226
217
        test('file:///bar/foo', 'file:///bar/', 'foo')
227
218
        test('http://host/foo', 'http://host/', 'foo')
228
219
        test('http://host/', 'http://host', '')
229
 
 
 
220
        
230
221
        # Invalid joinings
231
222
        # Cannot go above root
232
 
        # Implicitly at root:
233
223
        self.assertRaises(InvalidURLJoin, urlutils.join,
234
224
                'http://foo', '../baz')
235
 
        self.assertRaises(InvalidURLJoin, urlutils.join,
236
 
                'http://foo', '/..')
237
 
        # Joining from a path explicitly under the root.
238
 
        self.assertRaises(InvalidURLJoin, urlutils.join,
239
 
                'http://foo/a', '../../b')
240
 
 
241
 
    def test_joinpath(self):
242
 
        def test(expected, *args):
243
 
            joined = urlutils.joinpath(*args)
244
 
            self.assertEqual(expected, joined)
245
 
 
246
 
        # Test a single element
247
 
        test('foo', 'foo')
248
 
 
249
 
        # Test relative path joining
250
 
        test('foo/bar', 'foo', 'bar')
251
 
        test('foo/bar', 'foo', '.', 'bar')
252
 
        test('foo/baz', 'foo', 'bar', '../baz')
253
 
        test('foo/bar/baz', 'foo', 'bar/baz')
254
 
        test('foo/baz', 'foo', 'bar/../baz')
255
 
 
256
 
        # Test joining to an absolute path
257
 
        test('/foo', '/foo')
258
 
        test('/foo', '/foo', '.')
259
 
        test('/foo/bar', '/foo', 'bar')
260
 
        test('/', '/foo', '..')
261
 
 
262
 
        # Test joining with an absolute path
263
 
        test('/bar', 'foo', '/bar')
264
 
 
265
 
        # Test joining to a path with a trailing slash
266
 
        test('foo/bar', 'foo/', 'bar')
267
 
 
268
 
        # Invalid joinings
269
 
        # Cannot go above root
270
 
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
271
 
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
272
 
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
273
225
 
274
226
    def test_function_type(self):
275
227
        if sys.platform == 'win32':
290
242
            raise TestSkipped("local encoding cannot handle unicode")
291
243
 
292
244
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
293
 
        self.assertFalse(isinstance(result, unicode))
294
245
 
295
246
    def test_posix_local_path_from_url(self):
296
247
        from_url = urlutils._posix_local_path_from_url
305
256
 
306
257
    def test_win32_local_path_to_url(self):
307
258
        to_url = urlutils._win32_local_path_to_url
308
 
        self.assertEqual('file:///C:/path/to/foo',
 
259
        self.assertEqual('file:///c:/path/to/foo',
309
260
            to_url('C:/path/to/foo'))
310
261
        # BOGUS: on win32, ntpath.abspath will strip trailing
311
262
        #       whitespace, so this will always fail
313
264
        #       and thus will succeed
314
265
        # self.assertEqual('file:///C:/path/to/foo%20',
315
266
        #     to_url('C:/path/to/foo '))
316
 
        self.assertEqual('file:///C:/path/to/f%20oo',
 
267
        self.assertEqual('file:///c:/path/to/f%20oo',
317
268
            to_url('C:/path/to/f oo'))
318
269
 
319
 
        self.assertEqual('file:///', to_url('/'))
320
 
 
321
270
        try:
322
271
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
323
272
        except UnicodeError:
324
273
            raise TestSkipped("local encoding cannot handle unicode")
325
274
 
326
 
        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
327
 
        self.assertFalse(isinstance(result, unicode))
328
 
 
329
 
    def test_win32_unc_path_to_url(self):
330
 
        to_url = urlutils._win32_local_path_to_url
331
 
        self.assertEqual('file://HOST/path',
332
 
            to_url(r'\\HOST\path'))
333
 
        self.assertEqual('file://HOST/path',
334
 
            to_url('//HOST/path'))
335
 
 
336
 
        try:
337
 
            result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')
338
 
        except UnicodeError:
339
 
            raise TestSkipped("local encoding cannot handle unicode")
340
 
 
341
 
        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
342
 
        self.assertFalse(isinstance(result, unicode))
 
275
        self.assertEqual('file:///d:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
343
276
 
344
277
    def test_win32_local_path_from_url(self):
345
278
        from_url = urlutils._win32_local_path_from_url
346
 
        self.assertEqual('C:/path/to/foo',
 
279
        self.assertEqual('c:/path/to/foo',
347
280
            from_url('file:///C|/path/to/foo'))
348
 
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
 
281
        self.assertEqual(u'd:/path/to/r\xe4ksm\xf6rg\xe5s',
349
282
            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
350
 
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
 
283
        self.assertEqual(u'd:/path/to/r\xe4ksm\xf6rg\xe5s',
351
284
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
352
 
        self.assertEqual('/', from_url('file:///'))
353
285
 
354
286
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
355
287
        # Not a valid _win32 url, no drive letter
356
288
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
357
289
 
358
 
    def test_win32_unc_path_from_url(self):
359
 
        from_url = urlutils._win32_local_path_from_url
360
 
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
361
 
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
362
 
        # we want to use only 2 slashes
363
 
        # Firefox understand only 5 slashes in URL, but it's ugly
364
 
        self.assertRaises(InvalidURL, from_url, 'file:////HOST/path')
365
 
        self.assertRaises(InvalidURL, from_url, 'file://///HOST/path')
366
 
        self.assertRaises(InvalidURL, from_url, 'file://////HOST/path')
367
 
        # check for file://C:/ instead of file:///C:/
368
 
        self.assertRaises(InvalidURL, from_url, 'file://C:/path')
369
 
 
370
 
    def test_win32_extract_drive_letter(self):
 
290
    def test__win32_extract_drive_letter(self):
371
291
        extract = urlutils._win32_extract_drive_letter
372
292
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
373
293
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
408
328
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
409
329
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
410
330
 
411
 
    def test_win32_strip_local_trailing_slash(self):
 
331
    def test__win32_strip_local_trailing_slash(self):
412
332
        strip = urlutils._win32_strip_local_trailing_slash
413
333
        self.assertEqual('file://', strip('file://'))
414
334
        self.assertEqual('file:///', strip('file:///'))
460
380
 
461
381
        test('http://foo', 'http://foo')
462
382
        if sys.platform == 'win32':
463
 
            test('C:/foo/path', 'file:///C|/foo/path')
464
 
            test('C:/foo/path', 'file:///C:/foo/path')
 
383
            test('c:/foo/path', 'file:///C|/foo/path')
 
384
            test('c:/foo/path', 'file:///C:/foo/path')
465
385
        else:
466
386
            test('/foo/path', 'file:///foo/path')
467
387
 
495
415
    def test_escape(self):
496
416
        self.assertEqual('%25', urlutils.escape('%'))
497
417
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
498
 
        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
499
 
 
500
 
    def test_escape_tildes(self):
501
 
        self.assertEqual('~foo', urlutils.escape('~foo'))
502
418
 
503
419
    def test_unescape(self):
504
420
        self.assertEqual('%', urlutils.unescape('%25'))
516
432
        def test(expected, base, other):
517
433
            result = urlutils.relative_url(base, other)
518
434
            self.assertEqual(expected, result)
519
 
 
 
435
            
520
436
        test('a', 'http://host/', 'http://host/a')
521
437
        test('http://entirely/different', 'sftp://host/branch',
522
438
                    'http://entirely/different')
531
447
                    'sftp://host/home/jelmer/branch/2b')
532
448
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
533
449
                    'http://host/home/jelmer/branch/feature/%2b')
534
 
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
 
450
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/', 
535
451
                    'http://host/home/jelmer/branch/feature/2b')
536
452
        # relative_url should preserve a trailing slash
537
453
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
548
464
        test('http://host/', 'http://host', 'http://host/')
549
465
        #test('.', 'http://host/', 'http://host')
550
466
        test('http://host', 'http://host/', 'http://host')
551
 
 
552
 
        # On Windows file:///C:/path/to and file:///D:/other/path
553
 
        # should not use relative url over the non-existent '/' directory.
554
 
        if sys.platform == 'win32':
555
 
            # on the same drive
556
 
            test('../../other/path',
557
 
                'file:///C:/path/to', 'file:///C:/other/path')
558
 
            #~next two tests is failed, i.e. urlutils.relative_url expects
559
 
            #~to see normalized file URLs?
560
 
            #~test('../../other/path',
561
 
            #~    'file:///C:/path/to', 'file:///c:/other/path')
562
 
            #~test('../../other/path',
563
 
            #~    'file:///C:/path/to', 'file:///C|/other/path')
564
 
 
565
 
            # check UNC paths too
566
 
            test('../../other/path',
567
 
                'file://HOST/base/path/to', 'file://HOST/base/other/path')
568
 
            # on different drives
569
 
            test('file:///D:/other/path',
570
 
                'file:///C:/path/to', 'file:///D:/other/path')
571
 
            # TODO: strictly saying in UNC path //HOST/base is full analog
572
 
            # of drive letter for hard disk, and this situation is also
573
 
            # should be exception from rules. [bialix 20071221]
574
 
 
575
 
 
576
 
class TestCwdToURL(TestCaseInTempDir):
577
 
    """Test that local_path_to_url works base on the cwd"""
578
 
 
579
 
    def test_dot(self):
580
 
        # This test will fail if getcwd is not ascii
581
 
        os.mkdir('mytest')
582
 
        os.chdir('mytest')
583
 
 
584
 
        url = urlutils.local_path_to_url('.')
585
 
        self.assertEndsWith(url, '/mytest')
586
 
 
587
 
    def test_non_ascii(self):
588
 
        if win32utils.winver == 'Windows 98':
589
 
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
590
 
 
591
 
        try:
592
 
            os.mkdir(u'dod\xe9')
593
 
        except UnicodeError:
594
 
            raise TestSkipped('cannot create unicode directory')
595
 
 
596
 
        os.chdir(u'dod\xe9')
597
 
 
598
 
        # On Mac OSX this directory is actually:
599
 
        #   u'/dode\u0301' => '/dode\xcc\x81
600
 
        # but we should normalize it back to
601
 
        #   u'/dod\xe9' => '/dod\xc3\xa9'
602
 
        url = urlutils.local_path_to_url('.')
603
 
        self.assertEndsWith(url, '/dod%C3%A9')
604
 
 
605
 
 
606
 
class TestDeriveToLocation(TestCase):
607
 
    """Test that the mapping of FROM_LOCATION to TO_LOCATION works."""
608
 
 
609
 
    def test_to_locations_derived_from_paths(self):
610
 
        derive = urlutils.derive_to_location
611
 
        self.assertEqual("bar", derive("bar"))
612
 
        self.assertEqual("bar", derive("../bar"))
613
 
        self.assertEqual("bar", derive("/foo/bar"))
614
 
        self.assertEqual("bar", derive("c:/foo/bar"))
615
 
        self.assertEqual("bar", derive("c:bar"))
616
 
 
617
 
    def test_to_locations_derived_from_urls(self):
618
 
        derive = urlutils.derive_to_location
619
 
        self.assertEqual("bar", derive("http://foo/bar"))
620
 
        self.assertEqual("bar", derive("bzr+ssh://foo/bar"))
621
 
        self.assertEqual("foo-bar", derive("lp:foo-bar"))
622
 
 
623
 
 
624
 
class TestRebaseURL(TestCase):
625
 
    """Test the behavior of rebase_url."""
626
 
 
627
 
    def test_non_relative(self):
628
 
        result = urlutils.rebase_url('file://foo', 'file://foo',
629
 
                                     'file://foo/bar')
630
 
        self.assertEqual('file://foo', result)
631
 
        result = urlutils.rebase_url('/foo', 'file://foo',
632
 
                                     'file://foo/bar')
633
 
        self.assertEqual('/foo', result)
634
 
 
635
 
    def test_different_ports(self):
636
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
637
 
                              'foo', 'http://bar:80', 'http://bar:81')
638
 
        self.assertEqual(str(e), "URLs differ by more than path:"
639
 
                         " 'http://bar:80' and 'http://bar:81'")
640
 
 
641
 
    def test_different_hosts(self):
642
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
643
 
                              'foo', 'http://bar', 'http://baz')
644
 
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
645
 
                         " and 'http://baz'")
646
 
 
647
 
    def test_different_protocol(self):
648
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
649
 
                              'foo', 'http://bar', 'ftp://bar')
650
 
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
651
 
                         " and 'ftp://bar'")
652
 
 
653
 
    def test_rebase_success(self):
654
 
        self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',
655
 
                         'http://baz/qux'))
656
 
        self.assertEqual('qux/bar', urlutils.rebase_url('bar',
657
 
                         'http://baz/qux', 'http://baz/'))
658
 
        self.assertEqual('.', urlutils.rebase_url('foo',
659
 
                         'http://bar/', 'http://bar/foo/'))
660
 
        self.assertEqual('qux/bar', urlutils.rebase_url('../bar',
661
 
                         'http://baz/qux/foo', 'http://baz/'))
662
 
 
663
 
    def test_determine_relative_path(self):
664
 
        self.assertEqual('../../baz/bar',
665
 
                         urlutils.determine_relative_path(
666
 
                         '/qux/quxx', '/baz/bar'))
667
 
        self.assertEqual('..',
668
 
                         urlutils.determine_relative_path(
669
 
                         '/bar/baz', '/bar'))
670
 
        self.assertEqual('baz',
671
 
                         urlutils.determine_relative_path(
672
 
                         '/bar', '/bar/baz'))
673
 
        self.assertEqual('.', urlutils.determine_relative_path(
674
 
                         '/bar', '/bar'))
675
 
 
676
 
 
677
 
class TestParseURL(TestCase):
678
 
 
679
 
    def test_parse_url(self):
680
 
        self.assertEqual(urlutils.parse_url('http://example.com:80/one'),
681
 
            ('http', None, None, 'example.com', 80, '/one'))
682
 
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]/one'),
683
 
                ('http', None, None, '1:2:3::40', None, '/one'))
684
 
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]:80/one'),
685
 
                ('http', None, None, '1:2:3::40', 80, '/one'))