/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: Robert Collins
  • Date: 2008-08-20 02:07:36 UTC
  • mfrom: (3640 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3682.
  • Revision ID: robertc@robertcollins.net-20080820020736-g2xe4921zzxtymle
Merge bzr.dev

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
 
from bzrlib.errors import InvalidURL, InvalidURLJoin
24
 
import bzrlib.urlutils as urlutils
 
25
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
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'))
 
319
        
 
320
        self.assertEqual('file:///', to_url('/'))
253
321
 
254
322
        try:
255
323
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
257
325
            raise TestSkipped("local encoding cannot handle unicode")
258
326
 
259
327
        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
328
        self.assertFalse(isinstance(result, unicode))
 
329
 
 
330
    def test_win32_unc_path_to_url(self):
 
331
        to_url = urlutils._win32_local_path_to_url
 
332
        self.assertEqual('file://HOST/path',
 
333
            to_url(r'\\HOST\path'))
 
334
        self.assertEqual('file://HOST/path',
 
335
            to_url('//HOST/path'))
 
336
 
 
337
        try:
 
338
            result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')
 
339
        except UnicodeError:
 
340
            raise TestSkipped("local encoding cannot handle unicode")
 
341
 
 
342
        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
343
        self.assertFalse(isinstance(result, unicode))
260
344
 
261
345
    def test_win32_local_path_from_url(self):
262
346
        from_url = urlutils._win32_local_path_from_url
266
350
            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
267
351
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
268
352
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
 
353
        self.assertEqual('/', from_url('file:///'))
269
354
 
270
355
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
271
356
        # Not a valid _win32 url, no drive letter
272
357
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
273
358
 
 
359
    def test_win32_unc_path_from_url(self):
 
360
        from_url = urlutils._win32_local_path_from_url
 
361
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
 
362
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
 
363
        # we want to use only 2 slashes
 
364
        # Firefox understand only 5 slashes in URL, but it's ugly
 
365
        self.assertRaises(InvalidURL, from_url, 'file:////HOST/path')
 
366
        self.assertRaises(InvalidURL, from_url, 'file://///HOST/path')
 
367
        self.assertRaises(InvalidURL, from_url, 'file://////HOST/path')
 
368
        # check for file://C:/ instead of file:///C:/
 
369
        self.assertRaises(InvalidURL, from_url, 'file://C:/path')
 
370
 
 
371
    def test_win32_extract_drive_letter(self):
 
372
        extract = urlutils._win32_extract_drive_letter
 
373
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
 
374
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
 
375
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
 
376
 
274
377
    def test_split(self):
275
378
        # Test bzrlib.urlutils.split()
276
379
        split = urlutils.split
306
409
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
307
410
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
308
411
 
 
412
    def test_win32_strip_local_trailing_slash(self):
 
413
        strip = urlutils._win32_strip_local_trailing_slash
 
414
        self.assertEqual('file://', strip('file://'))
 
415
        self.assertEqual('file:///', strip('file:///'))
 
416
        self.assertEqual('file:///C', strip('file:///C'))
 
417
        self.assertEqual('file:///C:', strip('file:///C:'))
 
418
        self.assertEqual('file:///d|', strip('file:///d|'))
 
419
        self.assertEqual('file:///C:/', strip('file:///C:/'))
 
420
        self.assertEqual('file:///C:/a', strip('file:///C:/a/'))
 
421
 
309
422
    def test_strip_trailing_slash(self):
310
423
        sts = urlutils.strip_trailing_slash
311
424
        if sys.platform == 'win32':
383
496
    def test_escape(self):
384
497
        self.assertEqual('%25', urlutils.escape('%'))
385
498
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
 
499
        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
386
500
 
387
501
    def test_unescape(self):
388
502
        self.assertEqual('%', urlutils.unescape('%25'))
432
546
        test('http://host/', 'http://host', 'http://host/')
433
547
        #test('.', 'http://host/', 'http://host')
434
548
        test('http://host', 'http://host/', 'http://host')
 
549
 
 
550
        # On Windows file:///C:/path/to and file:///D:/other/path
 
551
        # should not use relative url over the non-existent '/' directory.
 
552
        if sys.platform == 'win32':
 
553
            # on the same drive
 
554
            test('../../other/path',
 
555
                'file:///C:/path/to', 'file:///C:/other/path')
 
556
            #~next two tests is failed, i.e. urlutils.relative_url expects
 
557
            #~to see normalized file URLs?
 
558
            #~test('../../other/path',
 
559
            #~    'file:///C:/path/to', 'file:///c:/other/path')
 
560
            #~test('../../other/path',
 
561
            #~    'file:///C:/path/to', 'file:///C|/other/path')
 
562
 
 
563
            # check UNC paths too
 
564
            test('../../other/path',
 
565
                'file://HOST/base/path/to', 'file://HOST/base/other/path')
 
566
            # on different drives
 
567
            test('file:///D:/other/path',
 
568
                'file:///C:/path/to', 'file:///D:/other/path')
 
569
            # TODO: strictly saying in UNC path //HOST/base is full analog
 
570
            # of drive letter for hard disk, and this situation is also
 
571
            # should be exception from rules. [bialix 20071221]
 
572
 
 
573
 
 
574
class TestCwdToURL(TestCaseInTempDir):
 
575
    """Test that local_path_to_url works base on the cwd"""
 
576
 
 
577
    def test_dot(self):
 
578
        # This test will fail if getcwd is not ascii
 
579
        os.mkdir('mytest')
 
580
        os.chdir('mytest')
 
581
 
 
582
        url = urlutils.local_path_to_url('.')
 
583
        self.assertEndsWith(url, '/mytest')
 
584
 
 
585
    def test_non_ascii(self):
 
586
        if win32utils.winver == 'Windows 98':
 
587
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
 
588
 
 
589
        try:
 
590
            os.mkdir(u'dod\xe9')
 
591
        except UnicodeError:
 
592
            raise TestSkipped('cannot create unicode directory')
 
593
 
 
594
        os.chdir(u'dod\xe9')
 
595
 
 
596
        # On Mac OSX this directory is actually: 
 
597
        #   u'/dode\u0301' => '/dode\xcc\x81
 
598
        # but we should normalize it back to 
 
599
        #   u'/dod\xe9' => '/dod\xc3\xa9'
 
600
        url = urlutils.local_path_to_url('.')
 
601
        self.assertEndsWith(url, '/dod%C3%A9')
 
602
 
 
603
 
 
604
class TestDeriveToLocation(TestCase):
 
605
    """Test that the mapping of FROM_LOCATION to TO_LOCATION works."""
 
606
 
 
607
    def test_to_locations_derived_from_paths(self):
 
608
        derive = urlutils.derive_to_location
 
609
        self.assertEqual("bar", derive("bar"))
 
610
        self.assertEqual("bar", derive("../bar"))
 
611
        self.assertEqual("bar", derive("/foo/bar"))
 
612
        self.assertEqual("bar", derive("c:/foo/bar"))
 
613
        self.assertEqual("bar", derive("c:bar"))
 
614
 
 
615
    def test_to_locations_derived_from_urls(self):
 
616
        derive = urlutils.derive_to_location
 
617
        self.assertEqual("bar", derive("http://foo/bar"))
 
618
        self.assertEqual("bar", derive("bzr+ssh://foo/bar"))
 
619
        self.assertEqual("foo-bar", derive("lp:foo-bar"))
 
620
 
 
621
 
 
622
class TestRebaseURL(TestCase):
 
623
    """Test the behavior of rebase_url."""
 
624
 
 
625
    def test_non_relative(self):
 
626
        result = urlutils.rebase_url('file://foo', 'file://foo',
 
627
                                     'file://foo/bar')
 
628
        self.assertEqual('file://foo', result)
 
629
        result = urlutils.rebase_url('/foo', 'file://foo',
 
630
                                     'file://foo/bar')
 
631
        self.assertEqual('/foo', result)
 
632
 
 
633
    def test_different_ports(self):
 
634
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
635
                              'foo', 'http://bar:80', 'http://bar:81')
 
636
        self.assertEqual(str(e), "URLs differ by more than path:"
 
637
                         " 'http://bar:80' and 'http://bar:81'")
 
638
 
 
639
    def test_different_hosts(self):
 
640
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
641
                              'foo', 'http://bar', 'http://baz')
 
642
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
 
643
                         " and 'http://baz'")
 
644
 
 
645
    def test_different_protocol(self):
 
646
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
647
                              'foo', 'http://bar', 'ftp://bar')
 
648
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
 
649
                         " and 'ftp://bar'")
 
650
 
 
651
    def test_rebase_success(self):
 
652
        self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',
 
653
                         'http://baz/qux'))
 
654
        self.assertEqual('qux/bar', urlutils.rebase_url('bar',
 
655
                         'http://baz/qux', 'http://baz/'))
 
656
        self.assertEqual('.', urlutils.rebase_url('foo',
 
657
                         'http://bar/', 'http://bar/foo/'))
 
658
        self.assertEqual('qux/bar', urlutils.rebase_url('../bar',
 
659
                         'http://baz/qux/foo', 'http://baz/'))
 
660
 
 
661
    def test_determine_relative_path(self):
 
662
        self.assertEqual('../../baz/bar',
 
663
                         urlutils.determine_relative_path(
 
664
                         '/qux/quxx', '/baz/bar'))
 
665
        self.assertEqual('..',
 
666
                         urlutils.determine_relative_path(
 
667
                         '/bar/baz', '/bar'))
 
668
        self.assertEqual('baz',
 
669
                         urlutils.determine_relative_path(
 
670
                         '/bar', '/bar/baz'))
 
671
        self.assertEqual('.', urlutils.determine_relative_path(
 
672
                         '/bar', '/bar'))