← 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: Robert Collins
  • Date: 2007-07-15 15:40:37 UTC
  • mto: (2592.3.33 repository)
  • mto: This revision was merged to the branch mainline in revision 2624.
  • Revision ID: robertc@robertcollins.net-20070715154037-3ar8g89decddc9su
Make GraphIndex accept nodes as key, value, references, so that the method
signature is closer to what a simple key->value index delivers. Also
change the behaviour when the reference list count is zero to accept
key, value as nodes, and emit key, value to make it identical in that case
to a simple key->value index. This may not be a good idea, but for now it
seems ok.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
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
 
21
21
import sys
22
22
 
23
23
from bzrlib import osutils, urlutils, win32utils
24
 
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
 
24
import bzrlib
 
25
from bzrlib.errors import InvalidURL, InvalidURLJoin
25
26
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
26
27
 
27
28
 
28
29
class TestUrlToPath(TestCase):
29
 
 
 
30
    
30
31
    def test_basename(self):
31
32
        # bzrlib.urlutils.basename
32
33
        # Test bzrlib.urlutils.split()
81
82
 
82
83
        # Local paths are assumed to *not* be escaped at all
83
84
        try:
84
 
            u'uni/\xb5'.encode(osutils.get_user_encoding())
 
85
            u'uni/\xb5'.encode(bzrlib.user_encoding)
85
86
        except UnicodeError:
86
 
            # locale cannot handle unicode
 
87
            # locale cannot handle unicode 
87
88
            pass
88
89
        else:
89
90
            norm_file('uni/%C2%B5', u'uni/\xb5')
226
227
        test('file:///bar/foo', 'file:///bar/', 'foo')
227
228
        test('http://host/foo', 'http://host/', 'foo')
228
229
        test('http://host/', 'http://host', '')
229
 
 
 
230
        
230
231
        # Invalid joinings
231
232
        # Cannot go above root
232
233
        # Implicitly at root:
264
265
 
265
266
        # Test joining to a path with a trailing slash
266
267
        test('foo/bar', 'foo/', 'bar')
267
 
 
 
268
        
268
269
        # Invalid joinings
269
270
        # Cannot go above root
270
271
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
290
291
            raise TestSkipped("local encoding cannot handle unicode")
291
292
 
292
293
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
293
 
        self.assertFalse(isinstance(result, unicode))
294
294
 
295
295
    def test_posix_local_path_from_url(self):
296
296
        from_url = urlutils._posix_local_path_from_url
316
316
        self.assertEqual('file:///C:/path/to/f%20oo',
317
317
            to_url('C:/path/to/f oo'))
318
318
 
319
 
        self.assertEqual('file:///', to_url('/'))
320
 
 
321
319
        try:
322
320
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
323
321
        except UnicodeError:
324
322
            raise TestSkipped("local encoding cannot handle unicode")
325
323
 
326
324
        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
327
 
        self.assertFalse(isinstance(result, unicode))
328
325
 
329
326
    def test_win32_unc_path_to_url(self):
330
327
        to_url = urlutils._win32_local_path_to_url
339
336
            raise TestSkipped("local encoding cannot handle unicode")
340
337
 
341
338
        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
342
 
        self.assertFalse(isinstance(result, unicode))
 
339
 
343
340
 
344
341
    def test_win32_local_path_from_url(self):
345
342
        from_url = urlutils._win32_local_path_from_url
349
346
            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
350
347
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
351
348
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
352
 
        self.assertEqual('/', from_url('file:///'))
353
349
 
354
350
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
355
351
        # Not a valid _win32 url, no drive letter
495
491
    def test_escape(self):
496
492
        self.assertEqual('%25', urlutils.escape('%'))
497
493
        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
494
 
503
495
    def test_unescape(self):
504
496
        self.assertEqual('%', urlutils.unescape('%25'))
516
508
        def test(expected, base, other):
517
509
            result = urlutils.relative_url(base, other)
518
510
            self.assertEqual(expected, result)
519
 
 
 
511
            
520
512
        test('a', 'http://host/', 'http://host/a')
521
513
        test('http://entirely/different', 'sftp://host/branch',
522
514
                    'http://entirely/different')
531
523
                    'sftp://host/home/jelmer/branch/2b')
532
524
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
533
525
                    'http://host/home/jelmer/branch/feature/%2b')
534
 
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
 
526
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/', 
535
527
                    'http://host/home/jelmer/branch/feature/2b')
536
528
        # relative_url should preserve a trailing slash
537
529
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
549
541
        #test('.', 'http://host/', 'http://host')
550
542
        test('http://host', 'http://host/', 'http://host')
551
543
 
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
544
 
576
545
class TestCwdToURL(TestCaseInTempDir):
577
546
    """Test that local_path_to_url works base on the cwd"""
595
564
 
596
565
        os.chdir(u'dod\xe9')
597
566
 
598
 
        # On Mac OSX this directory is actually:
 
567
        # On Mac OSX this directory is actually: 
599
568
        #   u'/dode\u0301' => '/dode\xcc\x81
600
 
        # but we should normalize it back to
 
569
        # but we should normalize it back to 
601
570
        #   u'/dod\xe9' => '/dod\xc3\xa9'
602
571
        url = urlutils.local_path_to_url('.')
603
572
        self.assertEndsWith(url, '/dod%C3%A9')
619
588
        self.assertEqual("bar", derive("http://foo/bar"))
620
589
        self.assertEqual("bar", derive("bzr+ssh://foo/bar"))
621
590
        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'))