/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 breezy/tests/test_urlutils.py

  • Committer: Jelmer Vernooij
  • Date: 2017-11-21 20:14:44 UTC
  • mfrom: (6821.1.1 ignore-warnings)
  • Revision ID: jelmer@jelmer.uk-20171121201444-dvb7yjku3zwjev83
Merge lp:~jelmer/brz/ignore-warnings.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_urlutils.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2015, 2016 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
19
19
import os
20
20
import sys
21
21
 
22
 
from bzrlib import osutils, urlutils, win32utils
23
 
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
24
 
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
 
22
from .. import osutils, urlutils, win32utils
 
23
from ..errors import (
 
24
    PathNotChild,
 
25
    )
 
26
from . import features, TestCaseInTempDir, TestCase, TestSkipped
25
27
 
26
28
 
27
29
class TestUrlToPath(TestCase):
28
30
 
29
31
    def test_basename(self):
30
 
        # bzrlib.urlutils.basename
31
 
        # Test bzrlib.urlutils.split()
 
32
        # breezy.urlutils.basename
 
33
        # Test breezy.urlutils.split()
32
34
        basename = urlutils.basename
33
35
        if sys.platform == 'win32':
34
 
            self.assertRaises(InvalidURL, basename, 'file:///path/to/foo')
 
36
            self.assertRaises(urlutils.InvalidURL, basename,
 
37
                    'file:///path/to/foo')
35
38
            self.assertEqual('foo', basename('file:///C|/foo'))
36
39
            self.assertEqual('foo', basename('file:///C:/foo'))
37
40
            self.assertEqual('', basename('file:///C:/'))
121
124
 
122
125
        # Normalize verifies URLs when they are not unicode
123
126
        # (indicating they did not come from the user)
124
 
        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
125
 
        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/ ')
126
130
 
127
131
    def test_url_scheme_re(self):
128
132
        # Test paths that may be URLs
156
160
        # Weird stuff
157
161
        # Can't have slashes or colons in the scheme
158
162
        test_one('/path/to/://foo', None)
159
 
        test_one('path:path://foo', None)
 
163
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
160
164
        # Must have more than one character for scheme
161
165
        test_one('C://foo', None)
162
166
        test_one('ab://foo', ('ab', 'foo'))
163
167
 
164
168
    def test_dirname(self):
165
 
        # Test bzrlib.urlutils.dirname()
 
169
        # Test breezy.urlutils.dirname()
166
170
        dirname = urlutils.dirname
167
171
        if sys.platform == 'win32':
168
 
            self.assertRaises(InvalidURL, dirname, 'file:///path/to/foo')
 
172
            self.assertRaises(urlutils.InvalidURL, dirname,
 
173
                'file:///path/to/foo')
169
174
            self.assertEqual('file:///C|/', dirname('file:///C|/foo'))
170
175
            self.assertEqual('file:///C|/', dirname('file:///C|/'))
171
176
        else:
195
200
            dirname('path/to/foo/', exclude_trailing_slash=False))
196
201
        self.assertEqual('path/..', dirname('path/../foo'))
197
202
        self.assertEqual('../path', dirname('../path/foo'))
 
203
    
 
204
    def test_is_url(self):
 
205
        self.assertTrue(urlutils.is_url('http://foo/bar'))
 
206
        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))
 
207
        self.assertTrue(urlutils.is_url('lp:foo/bar'))
 
208
        self.assertTrue(urlutils.is_url('file:///foo/bar'))
 
209
        self.assertFalse(urlutils.is_url(''))
 
210
        self.assertFalse(urlutils.is_url('foo'))
 
211
        self.assertFalse(urlutils.is_url('foo/bar'))
 
212
        self.assertFalse(urlutils.is_url('/foo'))
 
213
        self.assertFalse(urlutils.is_url('/foo/bar'))
 
214
        self.assertFalse(urlutils.is_url('C:/'))
 
215
        self.assertFalse(urlutils.is_url('C:/foo'))
 
216
        self.assertFalse(urlutils.is_url('C:/foo/bar'))
198
217
 
199
218
    def test_join(self):
200
219
        def test(expected, *args):
210
229
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
211
230
        test('http://foo/baz', 'http://foo', 'bar/../baz')
212
231
        test('http://foo/baz', 'http://foo/bar/', '../baz')
 
232
        test('lp:foo/bar', 'lp:foo', 'bar')
 
233
        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')
213
234
 
214
235
        # Absolute paths
215
236
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
219
240
        test('http://bar/', 'http://foo', 'http://bar/')
220
241
        test('http://bar/a', 'http://foo', 'http://bar/a')
221
242
        test('http://bar/a/', 'http://foo', 'http://bar/a/')
 
243
        test('lp:bar', 'http://foo', 'lp:bar')
 
244
        test('lp:bar', 'lp:foo', 'lp:bar')
 
245
        test('file:///stuff', 'lp:foo', 'file:///stuff')
222
246
 
223
247
        # From a base path
224
248
        test('file:///foo', 'file:///', 'foo')
229
253
        # Invalid joinings
230
254
        # Cannot go above root
231
255
        # Implicitly at root:
232
 
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
256
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
233
257
                'http://foo', '../baz')
234
 
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
258
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
235
259
                'http://foo', '/..')
236
260
        # Joining from a path explicitly under the root.
237
 
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
261
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
238
262
                'http://foo/a', '../../b')
239
263
 
240
264
    def test_joinpath(self):
266
290
 
267
291
        # Invalid joinings
268
292
        # Cannot go above root
269
 
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
270
 
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
271
 
        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
                '/..')
 
299
 
 
300
    def test_join_segment_parameters_raw(self):
 
301
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
 
302
        self.assertEqual("/somedir/path", 
 
303
            join_segment_parameters_raw("/somedir/path"))
 
304
        self.assertEqual("/somedir/path,rawdata", 
 
305
            join_segment_parameters_raw("/somedir/path", "rawdata"))
 
306
        self.assertRaises(urlutils.InvalidURLJoin,
 
307
            join_segment_parameters_raw, "/somedir/path",
 
308
                "rawdata1,rawdata2,rawdata3")
 
309
        self.assertEqual("/somedir/path,bla,bar",
 
310
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
 
311
        self.assertEqual("/somedir,exist=some/path,bla,bar",
 
312
            join_segment_parameters_raw("/somedir,exist=some/path",
 
313
                "bla", "bar"))
 
314
        self.assertRaises(TypeError, join_segment_parameters_raw, 
 
315
            "/somepath", 42)
 
316
 
 
317
    def test_join_segment_parameters(self):
 
318
        join_segment_parameters = urlutils.join_segment_parameters
 
319
        self.assertEqual("/somedir/path", 
 
320
            join_segment_parameters("/somedir/path", {}))
 
321
        self.assertEqual("/somedir/path,key1=val1", 
 
322
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
 
323
        self.assertRaises(urlutils.InvalidURLJoin,
 
324
            join_segment_parameters, "/somedir/path",
 
325
            {"branch": "brr,brr,brr"})
 
326
        self.assertRaises(urlutils.InvalidURLJoin,
 
327
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
 
328
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
 
329
            join_segment_parameters("/somedir/path", {
 
330
                "key1": "val1", "key2": "val2"}))
 
331
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
 
332
            join_segment_parameters("/somedir/path,key1=val1", {
 
333
                "key2": "val2"}))
 
334
        self.assertEqual("/somedir/path,key1=val2",
 
335
            join_segment_parameters("/somedir/path,key1=val1", {
 
336
                "key1": "val2"}))
 
337
        self.assertEqual("/somedir,exist=some/path,key1=val1",
 
338
            join_segment_parameters("/somedir,exist=some/path",
 
339
                {"key1": "val1"}))
 
340
        self.assertEqual("/,key1=val1,key2=val2",
 
341
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
 
342
        self.assertRaises(TypeError,
 
343
            join_segment_parameters, "/,key1=val1", {"foo": 42})
272
344
 
273
345
    def test_function_type(self):
274
346
        if sys.platform == 'win32':
275
 
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
276
 
            self.assertEqual(urlutils._win32_local_path_from_url, urlutils.local_path_from_url)
 
347
            self.assertEqual(urlutils._win32_local_path_to_url,
 
348
                urlutils.local_path_to_url)
 
349
            self.assertEqual(urlutils._win32_local_path_from_url,
 
350
                urlutils.local_path_from_url)
277
351
        else:
278
 
            self.assertEqual(urlutils._posix_local_path_to_url, urlutils.local_path_to_url)
279
 
            self.assertEqual(urlutils._posix_local_path_from_url, urlutils.local_path_from_url)
 
352
            self.assertEqual(urlutils._posix_local_path_to_url,
 
353
                urlutils.local_path_to_url)
 
354
            self.assertEqual(urlutils._posix_local_path_from_url,
 
355
                urlutils.local_path_from_url)
280
356
 
281
357
    def test_posix_local_path_to_url(self):
282
358
        to_url = urlutils._posix_local_path_to_url
283
359
        self.assertEqual('file:///path/to/foo',
284
360
            to_url('/path/to/foo'))
285
361
 
 
362
        self.assertEqual('file:///path/to/foo%2Cbar',
 
363
            to_url('/path/to/foo,bar'))
 
364
 
286
365
        try:
287
366
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
288
367
        except UnicodeError:
295
374
        from_url = urlutils._posix_local_path_from_url
296
375
        self.assertEqual('/path/to/foo',
297
376
            from_url('file:///path/to/foo'))
 
377
        self.assertEqual('/path/to/foo',
 
378
            from_url('file:///path/to/foo,branch=foo'))
298
379
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
299
380
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
300
381
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
302
383
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
303
384
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
304
385
 
305
 
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
 
386
        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
306
387
        self.assertRaises(
307
 
            InvalidURL, from_url,
 
388
            urlutils.InvalidURL, from_url,
308
389
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
309
390
 
310
391
    def test_win32_local_path_to_url(self):
322
403
 
323
404
        self.assertEqual('file:///', to_url('/'))
324
405
 
 
406
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
 
407
            to_url('C:/path/to/foo,bar'))
325
408
        try:
326
409
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
327
410
        except UnicodeError:
331
414
        self.assertFalse(isinstance(result, unicode))
332
415
 
333
416
    def test_win32_unc_path_to_url(self):
 
417
        self.requireFeature(features.win32_feature)
334
418
        to_url = urlutils._win32_local_path_to_url
335
419
        self.assertEqual('file://HOST/path',
336
420
            to_url(r'\\HOST\path'))
354
438
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
355
439
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
356
440
        self.assertEqual('/', from_url('file:///'))
 
441
        self.assertEqual('C:/path/to/foo',
 
442
            from_url('file:///C|/path/to/foo,branch=foo'))
357
443
 
358
 
        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')
359
447
        # Not a valid _win32 url, no drive letter
360
 
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
 
448
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///path/to/foo')
361
449
 
362
450
    def test_win32_unc_path_from_url(self):
363
451
        from_url = urlutils._win32_local_path_from_url
364
452
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
 
453
        self.assertEqual('//HOST/path',
 
454
            from_url('file://HOST/path,branch=foo'))
365
455
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
366
456
        # we want to use only 2 slashes
367
457
        # Firefox understand only 5 slashes in URL, but it's ugly
368
 
        self.assertRaises(InvalidURL, from_url, 'file:////HOST/path')
369
 
        self.assertRaises(InvalidURL, from_url, 'file://///HOST/path')
370
 
        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')
371
461
        # check for file://C:/ instead of file:///C:/
372
 
        self.assertRaises(InvalidURL, from_url, 'file://C:/path')
 
462
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://C:/path')
373
463
 
374
464
    def test_win32_extract_drive_letter(self):
375
465
        extract = urlutils._win32_extract_drive_letter
376
466
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
377
467
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
378
 
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
 
468
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/path')
 
469
        # Root drives without slash treated as invalid, see bug #841322
 
470
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
 
471
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:')
 
472
        # Invalid without drive separator or following forward slash
 
473
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C')
 
474
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:ool')
379
475
 
380
476
    def test_split(self):
381
 
        # Test bzrlib.urlutils.split()
 
477
        # Test breezy.urlutils.split()
382
478
        split = urlutils.split
383
479
        if sys.platform == 'win32':
384
 
            self.assertRaises(InvalidURL, split, 'file:///path/to/foo')
 
480
            self.assertRaises(urlutils.InvalidURL, split, 'file:///path/to/foo')
385
481
            self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))
386
482
            self.assertEqual(('file:///C:/', ''), split('file:///C:/'))
387
483
        else:
412
508
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
413
509
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
414
510
 
 
511
    def test_split_segment_parameters_raw(self):
 
512
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
 
513
        # Check relative references with absolute paths
 
514
        self.assertEqual(("/some/path", []),
 
515
            split_segment_parameters_raw("/some/path"))
 
516
        self.assertEqual(("/some/path", ["tip"]),
 
517
            split_segment_parameters_raw("/some/path,tip"))
 
518
        self.assertEqual(("/some,dir/path", ["tip"]),
 
519
            split_segment_parameters_raw("/some,dir/path,tip"))
 
520
        self.assertEqual(("/somedir/path", ["heads%2Ftip"]),
 
521
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
 
522
        self.assertEqual(("/somedir/path", ["heads%2Ftip", "bar"]),
 
523
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
 
524
        # Check relative references with relative paths
 
525
        self.assertEqual(("", ["key1=val1"]),
 
526
            split_segment_parameters_raw(",key1=val1"))
 
527
        self.assertEqual(("foo/", ["key1=val1"]),
 
528
            split_segment_parameters_raw("foo/,key1=val1"))
 
529
        self.assertEqual(("foo", ["key1=val1"]),
 
530
            split_segment_parameters_raw("foo,key1=val1"))
 
531
        self.assertEqual(("foo/base,la=bla/other/elements", []),
 
532
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
 
533
        self.assertEqual(("foo/base,la=bla/other/elements", ["a=b"]),
 
534
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
 
535
        # TODO: Check full URLs as well as relative references
 
536
 
 
537
    def test_split_segment_parameters(self):
 
538
        split_segment_parameters = urlutils.split_segment_parameters
 
539
        # Check relative references with absolute paths
 
540
        self.assertEqual(("/some/path", {}),
 
541
            split_segment_parameters("/some/path"))
 
542
        self.assertEqual(("/some/path", {"branch": "tip"}),
 
543
            split_segment_parameters("/some/path,branch=tip"))
 
544
        self.assertEqual(("/some,dir/path", {"branch": "tip"}),
 
545
            split_segment_parameters("/some,dir/path,branch=tip"))
 
546
        self.assertEqual(("/somedir/path", {"ref": "heads%2Ftip"}),
 
547
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
 
548
        self.assertEqual(("/somedir/path",
 
549
            {"ref": "heads%2Ftip", "key1": "val1"}),
 
550
            split_segment_parameters(
 
551
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
 
552
        self.assertEqual(("/somedir/path", {"ref": "heads%2F=tip"}),
 
553
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
 
554
        # Check relative references with relative paths
 
555
        self.assertEqual(("", {"key1": "val1"}),
 
556
            split_segment_parameters(",key1=val1"))
 
557
        self.assertEqual(("foo/", {"key1": "val1"}),
 
558
            split_segment_parameters("foo/,key1=val1"))
 
559
        self.assertEqual(("foo/base,key1=val1/other/elements", {}),
 
560
            split_segment_parameters("foo/base,key1=val1/other/elements"))
 
561
        self.assertEqual(("foo/base,key1=val1/other/elements",
 
562
            {"key2": "val2"}), split_segment_parameters(
 
563
                "foo/base,key1=val1/other/elements,key2=val2"))
 
564
        # TODO: Check full URLs as well as relative references
 
565
 
415
566
    def test_win32_strip_local_trailing_slash(self):
416
567
        strip = urlutils._win32_strip_local_trailing_slash
417
568
        self.assertEqual('file://', strip('file://'))
508
659
        self.assertEqual('%', urlutils.unescape('%25'))
509
660
        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
510
661
 
511
 
        self.assertRaises(InvalidURL, urlutils.unescape, u'\xe5')
512
 
        self.assertRaises(InvalidURL, urlutils.unescape, '\xe5')
513
 
        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')
514
665
 
515
666
    def test_escape_unescape(self):
516
667
        self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
578
729
 
579
730
 
580
731
class TestCwdToURL(TestCaseInTempDir):
581
 
    """Test that local_path_to_url works base on the cwd"""
 
732
    """Test that local_path_to_url works based on the cwd"""
582
733
 
583
734
    def test_dot(self):
584
735
        # This test will fail if getcwd is not ascii
589
740
        self.assertEndsWith(url, '/mytest')
590
741
 
591
742
    def test_non_ascii(self):
592
 
        if win32utils.winver == 'Windows 98':
593
 
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
594
 
 
595
743
        try:
596
744
            os.mkdir(u'dod\xe9')
597
745
        except UnicodeError:
637
785
        self.assertEqual('/foo', result)
638
786
 
639
787
    def test_different_ports(self):
640
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
788
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
641
789
                              'foo', 'http://bar:80', 'http://bar:81')
642
790
        self.assertEqual(str(e), "URLs differ by more than path:"
643
791
                         " 'http://bar:80' and 'http://bar:81'")
644
792
 
645
793
    def test_different_hosts(self):
646
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
794
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
647
795
                              'foo', 'http://bar', 'http://baz')
648
796
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
649
797
                         " and 'http://baz'")
650
798
 
651
799
    def test_different_protocol(self):
652
 
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
 
800
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
653
801
                              'foo', 'http://bar', 'ftp://bar')
654
802
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
655
803
                         " and 'ftp://bar'")
680
828
 
681
829
class TestParseURL(TestCase):
682
830
 
683
 
    def test_parse_url(self):
684
 
        self.assertEqual(urlutils.parse_url('http://example.com:80/one'),
685
 
            ('http', None, None, 'example.com', 80, '/one'))
686
 
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]/one'),
687
 
                ('http', None, None, '1:2:3::40', None, '/one'))
688
 
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]:80/one'),
689
 
                ('http', None, None, '1:2:3::40', 80, '/one'))
 
831
    def test_parse_simple(self):
 
832
        parsed = urlutils.parse_url('http://example.com:80/one')
 
833
        self.assertEqual(('http', None, None, 'example.com', 80, '/one'),
 
834
            parsed)
 
835
 
 
836
    def test_ipv6(self):
 
837
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
 
838
        self.assertEqual(('http', None, None, '1:2:3::40', None, '/one'),
 
839
            parsed)
 
840
 
 
841
    def test_ipv6_port(self):
 
842
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
 
843
        self.assertEqual(('http', None, None, '1:2:3::40', 80, '/one'),
 
844
            parsed)
 
845
 
 
846
 
 
847
class TestURL(TestCase):
 
848
 
 
849
    def test_parse_simple(self):
 
850
        parsed = urlutils.URL.from_string('http://example.com:80/one')
 
851
        self.assertEqual('http', parsed.scheme)
 
852
        self.assertIs(None, parsed.user)
 
853
        self.assertIs(None, parsed.password)
 
854
        self.assertEqual('example.com', parsed.host)
 
855
        self.assertEqual(80, parsed.port)
 
856
        self.assertEqual('/one', parsed.path)
 
857
 
 
858
    def test_ipv6(self):
 
859
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
 
860
        self.assertEqual('http', parsed.scheme)
 
861
        self.assertIs(None, parsed.port)
 
862
        self.assertIs(None, parsed.user)
 
863
        self.assertIs(None, parsed.password)
 
864
        self.assertEqual('1:2:3::40', parsed.host)
 
865
        self.assertEqual('/one', parsed.path)
 
866
 
 
867
    def test_ipv6_port(self):
 
868
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
869
        self.assertEqual('http', parsed.scheme)
 
870
        self.assertEqual('1:2:3::40', parsed.host)
 
871
        self.assertIs(None, parsed.user)
 
872
        self.assertIs(None, parsed.password)
 
873
        self.assertEqual(80, parsed.port)
 
874
        self.assertEqual('/one', parsed.path)
 
875
 
 
876
    def test_quoted(self):
 
877
        parsed = urlutils.URL.from_string(
 
878
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
 
879
        self.assertEqual(parsed.quoted_host, 'ex%41mple.com')
 
880
        self.assertEqual(parsed.host, 'exAmple.com')
 
881
        self.assertEqual(parsed.port, 2222)
 
882
        self.assertEqual(parsed.quoted_user, 'ro%62ey')
 
883
        self.assertEqual(parsed.user, 'robey')
 
884
        self.assertEqual(parsed.quoted_password, 'h%40t')
 
885
        self.assertEqual(parsed.password, 'h@t')
 
886
        self.assertEqual(parsed.path, '/path')
 
887
 
 
888
    def test_eq(self):
 
889
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
890
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
891
        self.assertEqual(parsed1, parsed2)
 
892
        self.assertEqual(parsed1, parsed1)
 
893
        parsed2.path = '/two'
 
894
        self.assertNotEqual(parsed1, parsed2)
 
895
 
 
896
    def test_repr(self):
 
897
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
898
        self.assertEqual(
 
899
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
 
900
            repr(parsed))
 
901
 
 
902
    def test_str(self):
 
903
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
904
        self.assertEqual('http://[1:2:3::40]:80/one', str(parsed))
 
905
 
 
906
    def test__combine_paths(self):
 
907
        combine = urlutils.URL._combine_paths
 
908
        self.assertEqual('/home/sarah/project/foo',
 
909
                         combine('/home/sarah', 'project/foo'))
 
910
        self.assertEqual('/etc',
 
911
                         combine('/home/sarah', '../../etc'))
 
912
        self.assertEqual('/etc',
 
913
                         combine('/home/sarah', '../../../etc'))
 
914
        self.assertEqual('/etc',
 
915
                         combine('/home/sarah', '/etc'))
 
916
 
 
917
    def test_clone(self):
 
918
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
919
        url1 = url.clone("two")
 
920
        self.assertEqual("/one/two", url1.path)
 
921
        url2 = url.clone("/two")
 
922
        self.assertEqual("/two", url2.path)
 
923
        url3 = url.clone()
 
924
        self.assertIsNot(url, url3)
 
925
        self.assertEqual(url, url3)
 
926
 
 
927
 
 
928
class TestFileRelpath(TestCase):
 
929
 
 
930
    # GZ 2011-11-18: A way to override all path handling functions to one
 
931
    #                platform or another for testing would be nice.
 
932
 
 
933
    def _with_posix_paths(self):
 
934
        self.overrideAttr(urlutils, "local_path_from_url",
 
935
            urlutils._posix_local_path_from_url)
 
936
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH", len("file:///"))
 
937
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
 
938
        self.overrideAttr(osutils, "abspath", osutils._posix_abspath)
 
939
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
 
940
        self.overrideAttr(osutils, "pathjoin", osutils.posixpath.join)
 
941
        self.overrideAttr(osutils, "split", osutils.posixpath.split)
 
942
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 1)
 
943
 
 
944
    def _with_win32_paths(self):
 
945
        self.overrideAttr(urlutils, "local_path_from_url",
 
946
            urlutils._win32_local_path_from_url)
 
947
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH",
 
948
            urlutils.WIN32_MIN_ABS_FILEURL_LENGTH)
 
949
        self.overrideAttr(osutils, "abspath", osutils._win32_abspath)
 
950
        self.overrideAttr(osutils, "normpath", osutils._win32_normpath)
 
951
        self.overrideAttr(osutils, "pathjoin", osutils._win32_pathjoin)
 
952
        self.overrideAttr(osutils, "split", osutils.ntpath.split)
 
953
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 3)
 
954
 
 
955
    def test_same_url_posix(self):
 
956
        self._with_posix_paths()
 
957
        self.assertEqual("",
 
958
            urlutils.file_relpath("file:///a", "file:///a"))
 
959
        self.assertEqual("",
 
960
            urlutils.file_relpath("file:///a", "file:///a/"))
 
961
        self.assertEqual("",
 
962
            urlutils.file_relpath("file:///a/", "file:///a"))
 
963
 
 
964
    def test_same_url_win32(self):
 
965
        self._with_win32_paths()
 
966
        self.assertEqual("",
 
967
            urlutils.file_relpath("file:///A:/", "file:///A:/"))
 
968
        self.assertEqual("",
 
969
            urlutils.file_relpath("file:///A|/", "file:///A:/"))
 
970
        self.assertEqual("",
 
971
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
 
972
        self.assertEqual("",
 
973
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
 
974
        self.assertEqual("",
 
975
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
 
976
 
 
977
    def test_child_posix(self):
 
978
        self._with_posix_paths()
 
979
        self.assertEqual("b",
 
980
            urlutils.file_relpath("file:///a", "file:///a/b"))
 
981
        self.assertEqual("b",
 
982
            urlutils.file_relpath("file:///a/", "file:///a/b"))
 
983
        self.assertEqual("b/c",
 
984
            urlutils.file_relpath("file:///a", "file:///a/b/c"))
 
985
 
 
986
    def test_child_win32(self):
 
987
        self._with_win32_paths()
 
988
        self.assertEqual("b",
 
989
            urlutils.file_relpath("file:///A:/", "file:///A:/b"))
 
990
        self.assertEqual("b",
 
991
            urlutils.file_relpath("file:///A|/", "file:///A:/b"))
 
992
        self.assertEqual("c",
 
993
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
 
994
        self.assertEqual("c",
 
995
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
 
996
        self.assertEqual("c/d",
 
997
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
 
998
 
 
999
    def test_sibling_posix(self):
 
1000
        self._with_posix_paths()
 
1001
        self.assertRaises(PathNotChild,
 
1002
            urlutils.file_relpath, "file:///a/b", "file:///a/c")
 
1003
        self.assertRaises(PathNotChild,
 
1004
            urlutils.file_relpath, "file:///a/b/", "file:///a/c")
 
1005
        self.assertRaises(PathNotChild,
 
1006
            urlutils.file_relpath, "file:///a/b/", "file:///a/c/")
 
1007
 
 
1008
    def test_sibling_win32(self):
 
1009
        self._with_win32_paths()
 
1010
        self.assertRaises(PathNotChild,
 
1011
            urlutils.file_relpath, "file:///A:/b", "file:///A:/c")
 
1012
        self.assertRaises(PathNotChild,
 
1013
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c")
 
1014
        self.assertRaises(PathNotChild,
 
1015
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c/")
 
1016
 
 
1017
    def test_parent_posix(self):
 
1018
        self._with_posix_paths()
 
1019
        self.assertRaises(PathNotChild,
 
1020
            urlutils.file_relpath, "file:///a/b", "file:///a")
 
1021
        self.assertRaises(PathNotChild,
 
1022
            urlutils.file_relpath, "file:///a/b", "file:///a/")
 
1023
 
 
1024
    def test_parent_win32(self):
 
1025
        self._with_win32_paths()
 
1026
        self.assertRaises(PathNotChild,
 
1027
            urlutils.file_relpath, "file:///A:/b", "file:///A:/")
 
1028
        self.assertRaises(PathNotChild,
 
1029
            urlutils.file_relpath, "file:///A:/b/c", "file:///A:/b")
 
1030
 
 
1031
 
 
1032
class QuoteTests(TestCase):
 
1033
 
 
1034
    def test_quote(self):
 
1035
        self.assertEqual('abc%20def', urlutils.quote('abc def'))
 
1036
        self.assertEqual('abc%2Fdef', urlutils.quote('abc/def', safe=''))
 
1037
        self.assertEqual('abc/def', urlutils.quote('abc/def', safe='/'))
 
1038
 
 
1039
    def test_quote_tildes(self):
 
1040
        self.assertEqual('%7Efoo', urlutils.quote('~foo'))
 
1041
        self.assertEqual('~foo', urlutils.quote('~foo', safe='/~'))
 
1042
 
 
1043
    def test_unquote(self):
 
1044
        self.assertEqual('%', urlutils.unquote('%25'))
 
1045
        self.assertEqual('\xc3\xa5', urlutils.unquote('%C3%A5'))
 
1046
        self.assertEqual(u"\xe5", urlutils.unquote(u'\xe5'))