/breezy/trunk

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/trunk

« back to all changes in this revision

Viewing changes to breezy/tests/test_urlutils.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
21
21
 
22
22
from .. import osutils, urlutils, win32utils
23
23
from ..errors import (
24
 
    InvalidURL,
25
 
    InvalidURLJoin,
26
 
    InvalidRebaseURLs,
27
24
    PathNotChild,
28
25
    )
29
26
from . import features, TestCaseInTempDir, TestCase, TestSkipped
36
33
        # Test breezy.urlutils.split()
37
34
        basename = urlutils.basename
38
35
        if sys.platform == 'win32':
39
 
            self.assertRaises(InvalidURL, basename, 'file:///path/to/foo')
 
36
            self.assertRaises(urlutils.InvalidURL, basename,
 
37
                    'file:///path/to/foo')
40
38
            self.assertEqual('foo', basename('file:///C|/foo'))
41
39
            self.assertEqual('foo', basename('file:///C:/foo'))
42
40
            self.assertEqual('', basename('file:///C:/'))
126
124
 
127
125
        # Normalize verifies URLs when they are not unicode
128
126
        # (indicating they did not come from the user)
129
 
        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
130
 
        self.assertRaises(InvalidURL, normalize_url, 'http://host/ ')
 
127
        self.assertRaises(urlutils.InvalidURL, normalize_url,
 
128
                'http://host/\xb5')
 
129
        self.assertRaises(urlutils.InvalidURL, normalize_url, 'http://host/ ')
131
130
 
132
131
    def test_url_scheme_re(self):
133
132
        # Test paths that may be URLs
170
169
        # Test breezy.urlutils.dirname()
171
170
        dirname = urlutils.dirname
172
171
        if sys.platform == 'win32':
173
 
            self.assertRaises(InvalidURL, dirname, 'file:///path/to/foo')
 
172
            self.assertRaises(urlutils.InvalidURL, dirname,
 
173
                'file:///path/to/foo')
174
174
            self.assertEqual('file:///C|/', dirname('file:///C|/foo'))
175
175
            self.assertEqual('file:///C|/', dirname('file:///C|/'))
176
176
        else:
253
253
        # Invalid joinings
254
254
        # Cannot go above root
255
255
        # Implicitly at root:
256
 
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
256
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
257
257
                'http://foo', '../baz')
258
 
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
258
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
259
259
                'http://foo', '/..')
260
260
        # Joining from a path explicitly under the root.
261
 
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
261
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
262
262
                'http://foo/a', '../../b')
263
263
 
264
264
    def test_joinpath(self):
290
290
 
291
291
        # Invalid joinings
292
292
        # Cannot go above root
293
 
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
294
 
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
295
 
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
 
293
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
 
294
                '../baz')
 
295
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
 
296
                '..')
 
297
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
 
298
                '/..')
296
299
 
297
300
    def test_join_segment_parameters_raw(self):
298
301
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
300
303
            join_segment_parameters_raw("/somedir/path"))
301
304
        self.assertEqual("/somedir/path,rawdata", 
302
305
            join_segment_parameters_raw("/somedir/path", "rawdata"))
303
 
        self.assertRaises(InvalidURLJoin,
 
306
        self.assertRaises(urlutils.InvalidURLJoin,
304
307
            join_segment_parameters_raw, "/somedir/path",
305
308
                "rawdata1,rawdata2,rawdata3")
306
309
        self.assertEqual("/somedir/path,bla,bar",
317
320
            join_segment_parameters("/somedir/path", {}))
318
321
        self.assertEqual("/somedir/path,key1=val1", 
319
322
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
320
 
        self.assertRaises(InvalidURLJoin,
 
323
        self.assertRaises(urlutils.InvalidURLJoin,
321
324
            join_segment_parameters, "/somedir/path",
322
325
            {"branch": "brr,brr,brr"})
323
 
        self.assertRaises(InvalidURLJoin,
 
326
        self.assertRaises(urlutils.InvalidURLJoin,
324
327
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
325
328
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
326
329
            join_segment_parameters("/somedir/path", {
380
383
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
381
384
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
382
385
 
383
 
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
 
386
        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
384
387
        self.assertRaises(
385
 
            InvalidURL, from_url,
 
388
            urlutils.InvalidURL, from_url,
386
389
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
387
390
 
388
391
    def test_win32_local_path_to_url(self):
438
441
        self.assertEqual('C:/path/to/foo',
439
442
            from_url('file:///C|/path/to/foo,branch=foo'))
440
443
 
441
 
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
442
 
        self.assertRaises(InvalidURL, from_url, 'file:///c')
443
 
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
 
444
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///C:')
 
445
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///c')
 
446
        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
444
447
        # Not a valid _win32 url, no drive letter
445
 
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
 
448
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///path/to/foo')
446
449
 
447
450
    def test_win32_unc_path_from_url(self):
448
451
        from_url = urlutils._win32_local_path_from_url
452
455
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
453
456
        # we want to use only 2 slashes
454
457
        # Firefox understand only 5 slashes in URL, but it's ugly
455
 
        self.assertRaises(InvalidURL, from_url, 'file:////HOST/path')
456
 
        self.assertRaises(InvalidURL, from_url, 'file://///HOST/path')
457
 
        self.assertRaises(InvalidURL, from_url, 'file://////HOST/path')
 
458
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:////HOST/path')
 
459
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://///HOST/path')
 
460
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://////HOST/path')
458
461
        # check for file://C:/ instead of file:///C:/
459
 
        self.assertRaises(InvalidURL, from_url, 'file://C:/path')
 
462
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://C:/path')
460
463
 
461
464
    def test_win32_extract_drive_letter(self):
462
465
        extract = urlutils._win32_extract_drive_letter
463
466
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
464
467
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
465
 
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
 
468
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/path')
466
469
        # Root drives without slash treated as invalid, see bug #841322
467
470
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
468
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C:')
 
471
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:')
469
472
        # Invalid without drive separator or following forward slash
470
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C')
471
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C:ool')
 
473
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C')
 
474
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:ool')
472
475
 
473
476
    def test_split(self):
474
477
        # Test breezy.urlutils.split()
475
478
        split = urlutils.split
476
479
        if sys.platform == 'win32':
477
 
            self.assertRaises(InvalidURL, split, 'file:///path/to/foo')
 
480
            self.assertRaises(urlutils.InvalidURL, split, 'file:///path/to/foo')
478
481
            self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))
479
482
            self.assertEqual(('file:///C:/', ''), split('file:///C:/'))
480
483
        else:
656
659
        self.assertEqual('%', urlutils.unescape('%25'))
657
660
        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
658
661
 
659
 
        self.assertRaises(InvalidURL, urlutils.unescape, u'\xe5')
660
 
        self.assertRaises(InvalidURL, urlutils.unescape, '\xe5')
661
 
        self.assertRaises(InvalidURL, urlutils.unescape, '%E5')
 
662
        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, u'\xe5')
 
663
        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, '\xe5')
 
664
        self.assertRaises(urlutils.InvalidURL, urlutils.unescape, '%E5')
662
665
 
663
666
    def test_escape_unescape(self):
664
667
        self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
782
785
        self.assertEqual('/foo', result)
783
786
 
784
787
    def test_different_ports(self):
785
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
788
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
786
789
                              'foo', 'http://bar:80', 'http://bar:81')
787
790
        self.assertEqual(str(e), "URLs differ by more than path:"
788
791
                         " 'http://bar:80' and 'http://bar:81'")
789
792
 
790
793
    def test_different_hosts(self):
791
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
794
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
792
795
                              'foo', 'http://bar', 'http://baz')
793
796
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
794
797
                         " and 'http://baz'")
795
798
 
796
799
    def test_different_protocol(self):
797
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
800
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
798
801
                              'foo', 'http://bar', 'ftp://bar')
799
802
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
800
803
                         " and 'ftp://bar'")