← 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: 2009-10-02 20:32:50 UTC
  • mto: (4679.6.1 2.1-export-c-api)
  • mto: This revision was merged to the branch mainline in revision 4735.
  • Revision ID: john@arbash-meinel.com-20091002203250-q6iv6o2mwjqp4g53
Add __iter__ support.

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
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the urlutils wrapper."""
18
18
 
20
20
import re
21
21
import sys
22
22
 
23
 
from bzrlib import osutils, urlutils
24
 
import bzrlib
25
 
from bzrlib.errors import InvalidURL, InvalidURLJoin
 
23
from bzrlib import osutils, urlutils, win32utils
 
24
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
26
25
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
27
26
 
28
27
 
29
28
class TestUrlToPath(TestCase):
30
 
    
 
29
 
31
30
    def test_basename(self):
32
31
        # bzrlib.urlutils.basename
33
32
        # Test bzrlib.urlutils.split()
82
81
 
83
82
        # Local paths are assumed to *not* be escaped at all
84
83
        try:
85
 
            u'uni/\xb5'.encode(bzrlib.user_encoding)
 
84
            u'uni/\xb5'.encode(osutils.get_user_encoding())
86
85
        except UnicodeError:
87
 
            # locale cannot handle unicode 
 
86
            # locale cannot handle unicode
88
87
            pass
89
88
        else:
90
89
            norm_file('uni/%C2%B5', u'uni/\xb5')
115
114
        eq('http://host/ab/%C2%B5/%C2%B5',
116
115
            normalize_url(u'http://host/ab/%C2%B5/\xb5'))
117
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
 
118
123
        # Normalize verifies URLs when they are not unicode
119
124
        # (indicating they did not come from the user)
120
125
        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
197
202
            joined = urlutils.join(*args)
198
203
            self.assertEqual(expected, joined)
199
204
 
200
 
        # Test a single element
201
 
        test('foo', 'foo')
202
 
 
203
205
        # Test relative path joining
 
206
        test('foo', 'foo') # relative fragment with nothing is preserved.
204
207
        test('foo/bar', 'foo', 'bar')
205
208
        test('http://foo/bar', 'http://foo', 'bar')
206
209
        test('http://foo/bar', 'http://foo', '.', 'bar')
207
210
        test('http://foo/baz', 'http://foo', 'bar', '../baz')
208
211
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
209
212
        test('http://foo/baz', 'http://foo', 'bar/../baz')
 
213
        test('http://foo/baz', 'http://foo/bar/', '../baz')
210
214
 
211
215
        # Absolute paths
 
216
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
212
217
        test('http://bar', 'http://foo', 'http://bar')
213
218
        test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')
214
219
        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/')
215
223
 
216
224
        # From a base path
217
225
        test('file:///foo', 'file:///', 'foo')
218
226
        test('file:///bar/foo', 'file:///bar/', 'foo')
219
227
        test('http://host/foo', 'http://host/', 'foo')
220
228
        test('http://host/', 'http://host', '')
221
 
        
 
229
 
222
230
        # Invalid joinings
223
231
        # Cannot go above root
 
232
        # Implicitly at root:
224
233
        self.assertRaises(InvalidURLJoin, urlutils.join,
225
234
                '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, '/', '/..')
226
273
 
227
274
    def test_function_type(self):
228
275
        if sys.platform == 'win32':
243
290
            raise TestSkipped("local encoding cannot handle unicode")
244
291
 
245
292
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
293
        self.assertFalse(isinstance(result, unicode))
246
294
 
247
295
    def test_posix_local_path_from_url(self):
248
296
        from_url = urlutils._posix_local_path_from_url
268
316
        self.assertEqual('file:///C:/path/to/f%20oo',
269
317
            to_url('C:/path/to/f oo'))
270
318
 
 
319
        self.assertEqual('file:///', to_url('/'))
 
320
 
271
321
        try:
272
322
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
273
323
        except UnicodeError:
274
324
            raise TestSkipped("local encoding cannot handle unicode")
275
325
 
276
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))
277
343
 
278
344
    def test_win32_local_path_from_url(self):
279
345
        from_url = urlutils._win32_local_path_from_url
283
349
            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
284
350
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
285
351
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
 
352
        self.assertEqual('/', from_url('file:///'))
286
353
 
287
354
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
288
355
        # Not a valid _win32 url, no drive letter
289
356
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
290
357
 
291
 
    def test__win32_extract_drive_letter(self):
 
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):
292
371
        extract = urlutils._win32_extract_drive_letter
293
372
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
294
373
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
329
408
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
330
409
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
331
410
 
332
 
    def test__win32_strip_local_trailing_slash(self):
 
411
    def test_win32_strip_local_trailing_slash(self):
333
412
        strip = urlutils._win32_strip_local_trailing_slash
334
413
        self.assertEqual('file://', strip('file://'))
335
414
        self.assertEqual('file:///', strip('file:///'))
416
495
    def test_escape(self):
417
496
        self.assertEqual('%25', urlutils.escape('%'))
418
497
        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'))
419
502
 
420
503
    def test_unescape(self):
421
504
        self.assertEqual('%', urlutils.unescape('%25'))
433
516
        def test(expected, base, other):
434
517
            result = urlutils.relative_url(base, other)
435
518
            self.assertEqual(expected, result)
436
 
            
 
519
 
437
520
        test('a', 'http://host/', 'http://host/a')
438
521
        test('http://entirely/different', 'sftp://host/branch',
439
522
                    'http://entirely/different')
448
531
                    'sftp://host/home/jelmer/branch/2b')
449
532
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
450
533
                    'http://host/home/jelmer/branch/feature/%2b')
451
 
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/', 
 
534
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
452
535
                    'http://host/home/jelmer/branch/feature/2b')
453
536
        # relative_url should preserve a trailing slash
454
537
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
466
549
        #test('.', 'http://host/', 'http://host')
467
550
        test('http://host', 'http://host/', 'http://host')
468
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
 
469
575
 
470
576
class TestCwdToURL(TestCaseInTempDir):
471
577
    """Test that local_path_to_url works base on the cwd"""
479
585
        self.assertEndsWith(url, '/mytest')
480
586
 
481
587
    def test_non_ascii(self):
 
588
        if win32utils.winver == 'Windows 98':
 
589
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
 
590
 
482
591
        try:
483
592
            os.mkdir(u'dod\xe9')
484
593
        except UnicodeError:
486
595
 
487
596
        os.chdir(u'dod\xe9')
488
597
 
489
 
        # On Mac OSX this directory is actually: 
 
598
        # On Mac OSX this directory is actually:
490
599
        #   u'/dode\u0301' => '/dode\xcc\x81
491
 
        # but we should normalize it back to 
 
600
        # but we should normalize it back to
492
601
        #   u'/dod\xe9' => '/dod\xc3\xa9'
493
602
        url = urlutils.local_path_to_url('.')
494
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'))