/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: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2006-2012, 2015, 2016 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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 .. import osutils, urlutils
23
 
from ..errors import (
24
 
    PathNotChild,
25
 
    )
26
 
from ..sixish import (
27
 
    text_type,
28
 
    PY3,
29
 
    )
30
 
from . import features, TestCaseInTempDir, TestCase, TestSkipped
 
22
from bzrlib import osutils, urlutils, win32utils
 
23
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
 
24
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
31
25
 
32
26
 
33
27
class TestUrlToPath(TestCase):
34
28
 
35
29
    def test_basename(self):
36
 
        # breezy.urlutils.basename
37
 
        # Test breezy.urlutils.split()
 
30
        # bzrlib.urlutils.basename
 
31
        # Test bzrlib.urlutils.split()
38
32
        basename = urlutils.basename
39
33
        if sys.platform == 'win32':
40
 
            self.assertRaises(urlutils.InvalidURL, basename,
41
 
                              'file:///path/to/foo')
 
34
            self.assertRaises(InvalidURL, basename, 'file:///path/to/foo')
42
35
            self.assertEqual('foo', basename('file:///C|/foo'))
43
36
            self.assertEqual('foo', basename('file:///C:/foo'))
44
37
            self.assertEqual('', basename('file:///C:/'))
48
41
 
49
42
        self.assertEqual('foo', basename('http://host/path/to/foo'))
50
43
        self.assertEqual('foo', basename('http://host/path/to/foo/'))
51
 
        self.assertEqual(
52
 
            '', basename('http://host/path/to/foo/',
53
 
                         exclude_trailing_slash=False))
 
44
        self.assertEqual('',
 
45
            basename('http://host/path/to/foo/', exclude_trailing_slash=False))
54
46
        self.assertEqual('path', basename('http://host/path'))
55
47
        self.assertEqual('', basename('http://host/'))
56
48
        self.assertEqual('', basename('http://host'))
57
49
        self.assertEqual('path', basename('http:///nohost/path'))
58
50
 
59
 
        self.assertEqual('path', basename(
60
 
            'random+scheme://user:pass@ahost:port/path'))
61
 
        self.assertEqual('path', basename(
62
 
            'random+scheme://user:pass@ahost:port/path/'))
 
51
        self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path'))
 
52
        self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path/'))
63
53
        self.assertEqual('', basename('random+scheme://user:pass@ahost:port/'))
64
54
 
65
55
        # relative paths
66
56
        self.assertEqual('foo', basename('path/to/foo'))
67
57
        self.assertEqual('foo', basename('path/to/foo/'))
68
58
        self.assertEqual('', basename('path/to/foo/',
69
 
                                      exclude_trailing_slash=False))
 
59
            exclude_trailing_slash=False))
70
60
        self.assertEqual('foo', basename('path/../foo'))
71
61
        self.assertEqual('foo', basename('../path/foo'))
72
62
 
125
115
 
126
116
        # Unescape characters that don't need to be escaped
127
117
        eq('http://host/~bob%2525-._',
128
 
           normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
 
118
                normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))
129
119
        eq('http://host/~bob%2525-._',
130
 
           normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
 
120
                normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))
131
121
 
132
 
        if not PY3:
133
 
            # On Python 2, normalize verifies URLs when they are not unicode
134
 
            # (indicating they did not come from the user)
135
 
            self.assertRaises(urlutils.InvalidURL, normalize_url,
136
 
                              b'http://host/\xb5')
137
 
            self.assertRaises(urlutils.InvalidURL,
138
 
                              normalize_url, b'http://host/ ')
 
122
        # Normalize verifies URLs when they are not unicode
 
123
        # (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/ ')
139
126
 
140
127
    def test_url_scheme_re(self):
141
128
        # Test paths that may be URLs
164
151
        test_one('file:///usr/bin', ('file', '/usr/bin'))
165
152
        test_one('file:///C:/Windows', ('file', '/C:/Windows'))
166
153
        test_one('file:///C|/Windows', ('file', '/C|/Windows'))
167
 
        test_one(u'readonly+sftp://host/path/\xe5',
168
 
                 ('readonly+sftp', u'host/path/\xe5'))
 
154
        test_one(u'readonly+sftp://host/path/\xe5', ('readonly+sftp', u'host/path/\xe5'))
169
155
 
170
156
        # Weird stuff
171
157
        # Can't have slashes or colons in the scheme
176
162
        test_one('ab://foo', ('ab', 'foo'))
177
163
 
178
164
    def test_dirname(self):
179
 
        # Test breezy.urlutils.dirname()
 
165
        # Test bzrlib.urlutils.dirname()
180
166
        dirname = urlutils.dirname
181
167
        if sys.platform == 'win32':
182
 
            self.assertRaises(urlutils.InvalidURL, dirname,
183
 
                              'file:///path/to/foo')
 
168
            self.assertRaises(InvalidURL, dirname, 'file:///path/to/foo')
184
169
            self.assertEqual('file:///C|/', dirname('file:///C|/foo'))
185
170
            self.assertEqual('file:///C|/', dirname('file:///C|/'))
186
171
        else:
187
172
            self.assertEqual('file:///', dirname('file:///foo'))
188
173
            self.assertEqual('file:///', dirname('file:///'))
189
174
 
190
 
        self.assertEqual('http://host/path/to',
191
 
                         dirname('http://host/path/to/foo'))
192
 
        self.assertEqual('http://host/path/to',
193
 
                         dirname('http://host/path/to/foo/'))
 
175
        self.assertEqual('http://host/path/to', dirname('http://host/path/to/foo'))
 
176
        self.assertEqual('http://host/path/to', dirname('http://host/path/to/foo/'))
194
177
        self.assertEqual('http://host/path/to/foo',
195
 
                         dirname('http://host/path/to/foo/',
196
 
                                 exclude_trailing_slash=False))
 
178
            dirname('http://host/path/to/foo/', exclude_trailing_slash=False))
197
179
        self.assertEqual('http://host/', dirname('http://host/path'))
198
180
        self.assertEqual('http://host/', dirname('http://host/'))
199
181
        self.assertEqual('http://host', dirname('http://host'))
200
182
        self.assertEqual('http:///nohost', dirname('http:///nohost/path'))
201
183
 
202
184
        self.assertEqual('random+scheme://user:pass@ahost:port/',
203
 
                         dirname('random+scheme://user:pass@ahost:port/path'))
204
 
        self.assertEqual('random+scheme://user:pass@ahost:port/',
205
 
                         dirname('random+scheme://user:pass@ahost:port/path/'))
206
 
        self.assertEqual('random+scheme://user:pass@ahost:port/',
207
 
                         dirname('random+scheme://user:pass@ahost:port/'))
 
185
            dirname('random+scheme://user:pass@ahost:port/path'))
 
186
        self.assertEqual('random+scheme://user:pass@ahost:port/',
 
187
            dirname('random+scheme://user:pass@ahost:port/path/'))
 
188
        self.assertEqual('random+scheme://user:pass@ahost:port/',
 
189
            dirname('random+scheme://user:pass@ahost:port/'))
208
190
 
209
191
        # relative paths
210
192
        self.assertEqual('path/to', dirname('path/to/foo'))
211
193
        self.assertEqual('path/to', dirname('path/to/foo/'))
212
194
        self.assertEqual('path/to/foo',
213
 
                         dirname('path/to/foo/', exclude_trailing_slash=False))
 
195
            dirname('path/to/foo/', exclude_trailing_slash=False))
214
196
        self.assertEqual('path/..', dirname('path/../foo'))
215
197
        self.assertEqual('../path', dirname('../path/foo'))
216
 
 
 
198
    
217
199
    def test_is_url(self):
218
200
        self.assertTrue(urlutils.is_url('http://foo/bar'))
219
201
        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))
234
216
            self.assertEqual(expected, joined)
235
217
 
236
218
        # Test relative path joining
237
 
        test('foo', 'foo')  # relative fragment with nothing is preserved.
 
219
        test('foo', 'foo') # relative fragment with nothing is preserved.
238
220
        test('foo/bar', 'foo', 'bar')
239
221
        test('http://foo/bar', 'http://foo', 'bar')
240
222
        test('http://foo/bar', 'http://foo', '.', 'bar')
246
228
        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')
247
229
 
248
230
        # Absolute paths
249
 
        test('http://foo', 'http://foo')  # abs url with nothing is preserved.
 
231
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
250
232
        test('http://bar', 'http://foo', 'http://bar')
251
233
        test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')
252
234
        test('file:///bar', 'foo', 'file:///bar')
266
248
        # Invalid joinings
267
249
        # Cannot go above root
268
250
        # Implicitly at root:
269
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
270
 
                          'http://foo', '../baz')
271
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
272
 
                          'http://foo', '/..')
 
251
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
252
                'http://foo', '../baz')
 
253
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
254
                'http://foo', '/..')
273
255
        # Joining from a path explicitly under the root.
274
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,
275
 
                          'http://foo/a', '../../b')
 
256
        self.assertRaises(InvalidURLJoin, urlutils.join,
 
257
                'http://foo/a', '../../b')
276
258
 
277
259
    def test_joinpath(self):
278
260
        def test(expected, *args):
303
285
 
304
286
        # Invalid joinings
305
287
        # Cannot go above root
306
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
307
 
                          '../baz')
308
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
309
 
                          '..')
310
 
        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',
311
 
                          '/..')
 
288
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
 
289
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
 
290
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
312
291
 
313
292
    def test_join_segment_parameters_raw(self):
314
293
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
315
 
        self.assertEqual("/somedir/path",
316
 
                         join_segment_parameters_raw("/somedir/path"))
317
 
        self.assertEqual("/somedir/path,rawdata",
318
 
                         join_segment_parameters_raw(
319
 
                             "/somedir/path", "rawdata"))
320
 
        self.assertRaises(urlutils.InvalidURLJoin,
321
 
                          join_segment_parameters_raw, "/somedir/path",
322
 
                          "rawdata1,rawdata2,rawdata3")
323
 
        self.assertEqual("/somedir/path,bla,bar",
324
 
                         join_segment_parameters_raw(
325
 
                             "/somedir/path", "bla", "bar"))
326
 
        self.assertEqual(
327
 
            "/somedir,exist=some/path,bla,bar",
 
294
        self.assertEquals("/somedir/path", 
 
295
            join_segment_parameters_raw("/somedir/path"))
 
296
        self.assertEquals("/somedir/path,rawdata", 
 
297
            join_segment_parameters_raw("/somedir/path", "rawdata"))
 
298
        self.assertRaises(InvalidURLJoin,
 
299
            join_segment_parameters_raw, "/somedir/path",
 
300
                "rawdata1,rawdata2,rawdata3")
 
301
        self.assertEquals("/somedir/path,bla,bar",
 
302
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
 
303
        self.assertEquals("/somedir,exist=some/path,bla,bar",
328
304
            join_segment_parameters_raw("/somedir,exist=some/path",
329
 
                                        "bla", "bar"))
330
 
        self.assertRaises(TypeError, join_segment_parameters_raw,
331
 
                          "/somepath", 42)
 
305
                "bla", "bar"))
 
306
        self.assertRaises(TypeError, join_segment_parameters_raw, 
 
307
            "/somepath", 42)
332
308
 
333
309
    def test_join_segment_parameters(self):
334
310
        join_segment_parameters = urlutils.join_segment_parameters
335
 
        self.assertEqual("/somedir/path",
336
 
                         join_segment_parameters("/somedir/path", {}))
337
 
        self.assertEqual(
338
 
            "/somedir/path,key1=val1",
 
311
        self.assertEquals("/somedir/path", 
 
312
            join_segment_parameters("/somedir/path", {}))
 
313
        self.assertEquals("/somedir/path,key1=val1", 
339
314
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
340
 
        self.assertRaises(urlutils.InvalidURLJoin,
341
 
                          join_segment_parameters, "/somedir/path",
342
 
                          {"branch": "brr,brr,brr"})
343
 
        self.assertRaises(
344
 
            urlutils.InvalidURLJoin,
 
315
        self.assertRaises(InvalidURLJoin,
 
316
            join_segment_parameters, "/somedir/path",
 
317
            {"branch": "brr,brr,brr"})
 
318
        self.assertRaises(InvalidURLJoin,
345
319
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
346
 
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
347
 
                         join_segment_parameters("/somedir/path", {
348
 
                             "key1": "val1", "key2": "val2"}))
349
 
        self.assertEqual("/somedir/path,key1=val1,key2=val2",
350
 
                         join_segment_parameters("/somedir/path,key1=val1", {
351
 
                             "key2": "val2"}))
352
 
        self.assertEqual("/somedir/path,key1=val2",
353
 
                         join_segment_parameters("/somedir/path,key1=val1", {
354
 
                             "key1": "val2"}))
355
 
        self.assertEqual("/somedir,exist=some/path,key1=val1",
356
 
                         join_segment_parameters("/somedir,exist=some/path",
357
 
                                                 {"key1": "val1"}))
358
 
        self.assertEqual(
359
 
            "/,key1=val1,key2=val2",
 
320
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
321
            join_segment_parameters("/somedir/path", {
 
322
                "key1": "val1", "key2": "val2"}))
 
323
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
324
            join_segment_parameters("/somedir/path,key1=val1", {
 
325
                "key2": "val2"}))
 
326
        self.assertEquals("/somedir/path,key1=val2",
 
327
            join_segment_parameters("/somedir/path,key1=val1", {
 
328
                "key1": "val2"}))
 
329
        self.assertEquals("/somedir,exist=some/path,key1=val1",
 
330
            join_segment_parameters("/somedir,exist=some/path",
 
331
                {"key1": "val1"}))
 
332
        self.assertEquals("/,key1=val1,key2=val2",
360
333
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
361
334
        self.assertRaises(TypeError,
362
 
                          join_segment_parameters, "/,key1=val1", {"foo": 42})
 
335
            join_segment_parameters, "/,key1=val1", {"foo": 42})
363
336
 
364
337
    def test_function_type(self):
365
338
        if sys.platform == 'win32':
366
 
            self.assertEqual(urlutils._win32_local_path_to_url,
367
 
                             urlutils.local_path_to_url)
368
 
            self.assertEqual(urlutils._win32_local_path_from_url,
369
 
                             urlutils.local_path_from_url)
 
339
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
 
340
            self.assertEqual(urlutils._win32_local_path_from_url, urlutils.local_path_from_url)
370
341
        else:
371
 
            self.assertEqual(urlutils._posix_local_path_to_url,
372
 
                             urlutils.local_path_to_url)
373
 
            self.assertEqual(urlutils._posix_local_path_from_url,
374
 
                             urlutils.local_path_from_url)
 
342
            self.assertEqual(urlutils._posix_local_path_to_url, urlutils.local_path_to_url)
 
343
            self.assertEqual(urlutils._posix_local_path_from_url, urlutils.local_path_from_url)
375
344
 
376
345
    def test_posix_local_path_to_url(self):
377
346
        to_url = urlutils._posix_local_path_to_url
378
347
        self.assertEqual('file:///path/to/foo',
379
 
                         to_url('/path/to/foo'))
380
 
 
381
 
        self.assertEqual('file:///path/to/foo%2Cbar',
382
 
                         to_url('/path/to/foo,bar'))
 
348
            to_url('/path/to/foo'))
383
349
 
384
350
        try:
385
351
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
387
353
            raise TestSkipped("local encoding cannot handle unicode")
388
354
 
389
355
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
390
 
        self.assertTrue(isinstance(result, str))
 
356
        self.assertFalse(isinstance(result, unicode))
391
357
 
392
358
    def test_posix_local_path_from_url(self):
393
359
        from_url = urlutils._posix_local_path_from_url
394
360
        self.assertEqual('/path/to/foo',
395
 
                         from_url('file:///path/to/foo'))
396
 
        self.assertEqual('/path/to/foo',
397
 
                         from_url('file:///path/to/foo,branch=foo'))
398
 
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
399
 
                         from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
400
 
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
401
 
                         from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
402
 
        self.assertEqual(
403
 
            u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
361
            from_url('file:///path/to/foo'))
 
362
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
363
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
 
364
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
 
365
            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
 
366
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
404
367
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
405
368
 
406
 
        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
 
369
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
407
370
        self.assertRaises(
408
 
            urlutils.InvalidURL, from_url,
 
371
            InvalidURL, from_url,
409
372
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
410
373
 
411
374
    def test_win32_local_path_to_url(self):
412
375
        to_url = urlutils._win32_local_path_to_url
413
376
        self.assertEqual('file:///C:/path/to/foo',
414
 
                         to_url('C:/path/to/foo'))
 
377
            to_url('C:/path/to/foo'))
415
378
        # BOGUS: on win32, ntpath.abspath will strip trailing
416
379
        #       whitespace, so this will always fail
417
380
        #       Though under linux, it fakes abspath support
419
382
        # self.assertEqual('file:///C:/path/to/foo%20',
420
383
        #     to_url('C:/path/to/foo '))
421
384
        self.assertEqual('file:///C:/path/to/f%20oo',
422
 
                         to_url('C:/path/to/f oo'))
 
385
            to_url('C:/path/to/f oo'))
423
386
 
424
387
        self.assertEqual('file:///', to_url('/'))
425
388
 
426
 
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
427
 
                         to_url('C:/path/to/foo,bar'))
428
389
        try:
429
390
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
430
391
        except UnicodeError:
431
392
            raise TestSkipped("local encoding cannot handle unicode")
432
393
 
433
 
        self.assertEqual(
434
 
            'file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
435
 
        self.assertIsInstance(result, str)
 
394
        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
395
        self.assertFalse(isinstance(result, unicode))
436
396
 
437
397
    def test_win32_unc_path_to_url(self):
438
 
        self.requireFeature(features.win32_feature)
439
398
        to_url = urlutils._win32_local_path_to_url
440
399
        self.assertEqual('file://HOST/path',
441
 
                         to_url(r'\\HOST\path'))
 
400
            to_url(r'\\HOST\path'))
442
401
        self.assertEqual('file://HOST/path',
443
 
                         to_url('//HOST/path'))
 
402
            to_url('//HOST/path'))
444
403
 
445
404
        try:
446
405
            result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')
447
406
        except UnicodeError:
448
407
            raise TestSkipped("local encoding cannot handle unicode")
449
408
 
450
 
        self.assertEqual(
451
 
            'file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
452
 
        self.assertFalse(isinstance(result, text_type))
 
409
        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
 
410
        self.assertFalse(isinstance(result, unicode))
453
411
 
454
412
    def test_win32_local_path_from_url(self):
455
413
        from_url = urlutils._win32_local_path_from_url
456
414
        self.assertEqual('C:/path/to/foo',
457
 
                         from_url('file:///C|/path/to/foo'))
458
 
        self.assertEqual(
459
 
            u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
 
415
            from_url('file:///C|/path/to/foo'))
 
416
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
460
417
            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
461
 
        self.assertEqual(
462
 
            u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
 
418
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
463
419
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
464
420
        self.assertEqual('/', from_url('file:///'))
465
 
        self.assertEqual('C:/path/to/foo',
466
 
                         from_url('file:///C|/path/to/foo,branch=foo'))
467
421
 
468
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///C:')
469
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///c')
470
 
        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')
 
422
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
471
423
        # Not a valid _win32 url, no drive letter
472
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///path/to/foo')
 
424
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
473
425
 
474
426
    def test_win32_unc_path_from_url(self):
475
427
        from_url = urlutils._win32_local_path_from_url
476
428
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
477
 
        self.assertEqual('//HOST/path',
478
 
                         from_url('file://HOST/path,branch=foo'))
479
429
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
480
430
        # we want to use only 2 slashes
481
431
        # Firefox understand only 5 slashes in URL, but it's ugly
482
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file:////HOST/path')
483
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://///HOST/path')
484
 
        self.assertRaises(urlutils.InvalidURL, from_url,
485
 
                          'file://////HOST/path')
 
432
        self.assertRaises(InvalidURL, from_url, 'file:////HOST/path')
 
433
        self.assertRaises(InvalidURL, from_url, 'file://///HOST/path')
 
434
        self.assertRaises(InvalidURL, from_url, 'file://////HOST/path')
486
435
        # check for file://C:/ instead of file:///C:/
487
 
        self.assertRaises(urlutils.InvalidURL, from_url, 'file://C:/path')
 
436
        self.assertRaises(InvalidURL, from_url, 'file://C:/path')
488
437
 
489
438
    def test_win32_extract_drive_letter(self):
490
439
        extract = urlutils._win32_extract_drive_letter
491
440
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
492
 
        self.assertEqual(('file:///d|', '/path'),
493
 
                         extract('file://', '/d|/path'))
494
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/path')
495
 
        # Root drives without slash treated as invalid, see bug #841322
496
 
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
497
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:')
498
 
        # Invalid without drive separator or following forward slash
499
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C')
500
 
        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:ool')
 
441
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
 
442
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
501
443
 
502
444
    def test_split(self):
503
 
        # Test breezy.urlutils.split()
 
445
        # Test bzrlib.urlutils.split()
504
446
        split = urlutils.split
505
447
        if sys.platform == 'win32':
506
 
            self.assertRaises(urlutils.InvalidURL, split,
507
 
                              'file:///path/to/foo')
 
448
            self.assertRaises(InvalidURL, split, 'file:///path/to/foo')
508
449
            self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))
509
450
            self.assertEqual(('file:///C:/', ''), split('file:///C:/'))
510
451
        else:
511
452
            self.assertEqual(('file:///', 'foo'), split('file:///foo'))
512
453
            self.assertEqual(('file:///', ''), split('file:///'))
513
454
 
514
 
        self.assertEqual(('http://host/path/to', 'foo'),
515
 
                         split('http://host/path/to/foo'))
516
 
        self.assertEqual(('http://host/path/to', 'foo'),
517
 
                         split('http://host/path/to/foo/'))
518
 
        self.assertEqual(
519
 
            ('http://host/path/to/foo', ''),
 
455
        self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo'))
 
456
        self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo/'))
 
457
        self.assertEqual(('http://host/path/to/foo', ''),
520
458
            split('http://host/path/to/foo/', exclude_trailing_slash=False))
521
459
        self.assertEqual(('http://host/', 'path'), split('http://host/path'))
522
460
        self.assertEqual(('http://host/', ''), split('http://host/'))
523
461
        self.assertEqual(('http://host', ''), split('http://host'))
524
 
        self.assertEqual(('http:///nohost', 'path'),
525
 
                         split('http:///nohost/path'))
 
462
        self.assertEqual(('http:///nohost', 'path'), split('http:///nohost/path'))
526
463
 
527
464
        self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
528
 
                         split('random+scheme://user:pass@ahost:port/path'))
 
465
            split('random+scheme://user:pass@ahost:port/path'))
529
466
        self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
530
 
                         split('random+scheme://user:pass@ahost:port/path/'))
 
467
            split('random+scheme://user:pass@ahost:port/path/'))
531
468
        self.assertEqual(('random+scheme://user:pass@ahost:port/', ''),
532
 
                         split('random+scheme://user:pass@ahost:port/'))
 
469
            split('random+scheme://user:pass@ahost:port/'))
533
470
 
534
471
        # relative paths
535
472
        self.assertEqual(('path/to', 'foo'), split('path/to/foo'))
536
473
        self.assertEqual(('path/to', 'foo'), split('path/to/foo/'))
537
474
        self.assertEqual(('path/to/foo', ''),
538
 
                         split('path/to/foo/', exclude_trailing_slash=False))
 
475
            split('path/to/foo/', exclude_trailing_slash=False))
539
476
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
540
477
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
541
478
 
542
 
    def test_strip_segment_parameters(self):
543
 
        strip_segment_parameters = urlutils.strip_segment_parameters
544
 
        # Check relative references with absolute paths
545
 
        self.assertEqual("/some/path",
546
 
                         strip_segment_parameters("/some/path"))
547
 
        self.assertEqual("/some/path",
548
 
                         strip_segment_parameters("/some/path,tip"))
549
 
        self.assertEqual("/some,dir/path",
550
 
                         strip_segment_parameters("/some,dir/path,tip"))
551
 
        self.assertEqual(
552
 
            "/somedir/path",
553
 
            strip_segment_parameters("/somedir/path,heads%2Ftip"))
554
 
        self.assertEqual(
555
 
            "/somedir/path",
556
 
            strip_segment_parameters("/somedir/path,heads%2Ftip,bar"))
557
 
        # Check relative references with relative paths
558
 
        self.assertEqual("", strip_segment_parameters(",key1=val1"))
559
 
        self.assertEqual("foo/", strip_segment_parameters("foo/,key1=val1"))
560
 
        self.assertEqual("foo", strip_segment_parameters("foo,key1=val1"))
561
 
        self.assertEqual(
562
 
            "foo/base,la=bla/other/elements",
563
 
            strip_segment_parameters("foo/base,la=bla/other/elements"))
564
 
        self.assertEqual(
565
 
            "foo/base,la=bla/other/elements",
566
 
            strip_segment_parameters("foo/base,la=bla/other/elements,a=b"))
567
 
        # TODO: Check full URLs as well as relative references
568
 
 
569
479
    def test_split_segment_parameters_raw(self):
570
480
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
571
 
        # Check relative references with absolute paths
572
 
        self.assertEqual(("/some/path", []),
573
 
                         split_segment_parameters_raw("/some/path"))
574
 
        self.assertEqual(("/some/path", ["tip"]),
575
 
                         split_segment_parameters_raw("/some/path,tip"))
576
 
        self.assertEqual(("/some,dir/path", ["tip"]),
577
 
                         split_segment_parameters_raw("/some,dir/path,tip"))
578
 
        self.assertEqual(
579
 
            ("/somedir/path", ["heads%2Ftip"]),
 
481
        self.assertEquals(("/some/path", []),
 
482
            split_segment_parameters_raw("/some/path"))
 
483
        self.assertEquals(("/some/path", ["tip"]),
 
484
            split_segment_parameters_raw("/some/path,tip"))
 
485
        self.assertEquals(("/some,dir/path", ["tip"]),
 
486
            split_segment_parameters_raw("/some,dir/path,tip"))
 
487
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
580
488
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
581
 
        self.assertEqual(
582
 
            ("/somedir/path", ["heads%2Ftip", "bar"]),
 
489
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
583
490
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
584
 
        # Check relative references with relative paths
585
 
        self.assertEqual(("", ["key1=val1"]),
586
 
                         split_segment_parameters_raw(",key1=val1"))
587
 
        self.assertEqual(("foo/", ["key1=val1"]),
588
 
                         split_segment_parameters_raw("foo/,key1=val1"))
589
 
        self.assertEqual(("foo", ["key1=val1"]),
590
 
                         split_segment_parameters_raw("foo,key1=val1"))
591
 
        self.assertEqual(
592
 
            ("foo/base,la=bla/other/elements", []),
 
491
        self.assertEquals(("/", ["key1=val1"]),
 
492
            split_segment_parameters_raw(",key1=val1"))
 
493
        self.assertEquals(("foo/", ["key1=val1"]),
 
494
            split_segment_parameters_raw("foo/,key1=val1"))
 
495
        self.assertEquals(("foo/base,la=bla/other/elements", []),
593
496
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
594
 
        self.assertEqual(
595
 
            ("foo/base,la=bla/other/elements", ["a=b"]),
 
497
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
596
498
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
597
 
        # TODO: Check full URLs as well as relative references
598
499
 
599
500
    def test_split_segment_parameters(self):
600
501
        split_segment_parameters = urlutils.split_segment_parameters
601
 
        # Check relative references with absolute paths
602
 
        self.assertEqual(("/some/path", {}),
603
 
                         split_segment_parameters("/some/path"))
604
 
        self.assertEqual(("/some/path", {"branch": "tip"}),
605
 
                         split_segment_parameters("/some/path,branch=tip"))
606
 
        self.assertEqual(("/some,dir/path", {"branch": "tip"}),
607
 
                         split_segment_parameters("/some,dir/path,branch=tip"))
608
 
        self.assertEqual(
609
 
            ("/somedir/path", {"ref": "heads%2Ftip"}),
 
502
        self.assertEquals(("/some/path", {}),
 
503
            split_segment_parameters("/some/path"))
 
504
        self.assertEquals(("/some/path", {"branch": "tip"}),
 
505
            split_segment_parameters("/some/path,branch=tip"))
 
506
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
 
507
            split_segment_parameters("/some,dir/path,branch=tip"))
 
508
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
610
509
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
611
 
        self.assertEqual(("/somedir/path",
612
 
                          {"ref": "heads%2Ftip", "key1": "val1"}),
613
 
                         split_segment_parameters(
614
 
            "/somedir/path,ref=heads%2Ftip,key1=val1"))
615
 
        self.assertEqual(
616
 
            ("/somedir/path", {"ref": "heads%2F=tip"}),
 
510
        self.assertEquals(("/somedir/path",
 
511
            {"ref": "heads%2Ftip", "key1": "val1"}),
 
512
            split_segment_parameters(
 
513
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
 
514
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
617
515
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
618
 
        # Check relative references with relative paths
619
 
        self.assertEqual(("", {"key1": "val1"}),
620
 
                         split_segment_parameters(",key1=val1"))
621
 
        self.assertEqual(("foo/", {"key1": "val1"}),
622
 
                         split_segment_parameters("foo/,key1=val1"))
623
 
        self.assertEqual(
624
 
            ("foo/base,key1=val1/other/elements", {}),
 
516
        self.assertEquals(("/", {"key1": "val1"}),
 
517
            split_segment_parameters(",key1=val1"))
 
518
        self.assertEquals(("foo/", {"key1": "val1"}),
 
519
            split_segment_parameters("foo/,key1=val1"))
 
520
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
625
521
            split_segment_parameters("foo/base,key1=val1/other/elements"))
626
 
        self.assertEqual(("foo/base,key1=val1/other/elements",
627
 
                          {"key2": "val2"}), split_segment_parameters(
628
 
            "foo/base,key1=val1/other/elements,key2=val2"))
629
 
        self.assertRaises(
630
 
            urlutils.InvalidURL, split_segment_parameters,
631
 
            "foo/base,key1")
632
 
        # TODO: Check full URLs as well as relative references
 
522
        self.assertEquals(("foo/base,key1=val1/other/elements",
 
523
            {"key2": "val2"}), split_segment_parameters(
 
524
                "foo/base,key1=val1/other/elements,key2=val2"))
633
525
 
634
526
    def test_win32_strip_local_trailing_slash(self):
635
527
        strip = urlutils._win32_strip_local_trailing_slash
662
554
        self.assertEqual('file://', sts('file://'))
663
555
 
664
556
        self.assertEqual('random+scheme://user:pass@ahost:port/path',
665
 
                         sts('random+scheme://user:pass@ahost:port/path'))
 
557
            sts('random+scheme://user:pass@ahost:port/path'))
666
558
        self.assertEqual('random+scheme://user:pass@ahost:port/path',
667
 
                         sts('random+scheme://user:pass@ahost:port/path/'))
 
559
            sts('random+scheme://user:pass@ahost:port/path/'))
668
560
        self.assertEqual('random+scheme://user:pass@ahost:port/',
669
 
                         sts('random+scheme://user:pass@ahost:port/'))
 
561
            sts('random+scheme://user:pass@ahost:port/'))
670
562
 
671
563
        # Make sure relative paths work too
672
564
        self.assertEqual('path/to/foo', sts('path/to/foo'))
678
570
        # Test that URLs are converted to nice unicode strings for display
679
571
        def test(expected, url, encoding='utf-8'):
680
572
            disp_url = urlutils.unescape_for_display(url, encoding=encoding)
681
 
            self.assertIsInstance(disp_url, text_type)
 
573
            self.assertIsInstance(disp_url, unicode)
682
574
            self.assertEqual(expected, disp_url)
683
575
 
684
576
        test('http://foo', 'http://foo')
718
610
    def test_escape(self):
719
611
        self.assertEqual('%25', urlutils.escape('%'))
720
612
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
721
 
        self.assertIsInstance(urlutils.escape(u'\xe5'), str)
 
613
        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
722
614
 
723
615
    def test_escape_tildes(self):
724
616
        self.assertEqual('~foo', urlutils.escape('~foo'))
727
619
        self.assertEqual('%', urlutils.unescape('%25'))
728
620
        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
729
621
 
730
 
        if not PY3:
731
 
            self.assertRaises(urlutils.InvalidURL, urlutils.unescape, u'\xe5')
732
 
        self.assertRaises((TypeError, urlutils.InvalidURL),
733
 
                          urlutils.unescape, b'\xe5')
734
 
        if not PY3:
735
 
            self.assertRaises(urlutils.InvalidURL, urlutils.unescape, '%E5')
736
 
        else:
737
 
            self.assertEqual('\xe5', urlutils.unescape('%C3%A5'))
 
622
        self.assertRaises(InvalidURL, urlutils.unescape, u'\xe5')
 
623
        self.assertRaises(InvalidURL, urlutils.unescape, '\xe5')
 
624
        self.assertRaises(InvalidURL, urlutils.unescape, '%E5')
738
625
 
739
626
    def test_escape_unescape(self):
740
627
        self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
747
634
 
748
635
        test('a', 'http://host/', 'http://host/a')
749
636
        test('http://entirely/different', 'sftp://host/branch',
750
 
             'http://entirely/different')
 
637
                    'http://entirely/different')
751
638
        test('../person/feature', 'http://host/branch/mainline',
752
 
             'http://host/branch/person/feature')
 
639
                    'http://host/branch/person/feature')
753
640
        test('..', 'http://host/branch', 'http://host/')
754
 
        test('http://host2/branch', 'http://host1/branch',
755
 
             'http://host2/branch')
 
641
        test('http://host2/branch', 'http://host1/branch', 'http://host2/branch')
756
642
        test('.', 'http://host1/branch', 'http://host1/branch')
757
643
        test('../../../branch/2b', 'file:///home/jelmer/foo/bar/2b',
758
 
             'file:///home/jelmer/branch/2b')
 
644
                    'file:///home/jelmer/branch/2b')
759
645
        test('../../branch/2b', 'sftp://host/home/jelmer/bar/2b',
760
 
             'sftp://host/home/jelmer/branch/2b')
 
646
                    'sftp://host/home/jelmer/branch/2b')
761
647
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
762
 
             'http://host/home/jelmer/branch/feature/%2b')
 
648
                    'http://host/home/jelmer/branch/feature/%2b')
763
649
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
764
 
             'http://host/home/jelmer/branch/feature/2b')
 
650
                    'http://host/home/jelmer/branch/feature/2b')
765
651
        # relative_url should preserve a trailing slash
766
652
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
767
 
             'http://host/home/jelmer/branch/feature/2b/')
 
653
                    'http://host/home/jelmer/branch/feature/2b/')
768
654
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b',
769
 
             'http://host/home/jelmer/branch/feature/2b/')
 
655
                    'http://host/home/jelmer/branch/feature/2b/')
770
656
 
771
657
        # TODO: treat http://host as http://host/
772
658
        #       relative_url is typically called from a branch.base or
773
659
        #       transport.base which always ends with a /
774
 
        # test('a', 'http://host', 'http://host/a')
 
660
        #test('a', 'http://host', 'http://host/a')
775
661
        test('http://host/a', 'http://host', 'http://host/a')
776
 
        # test('.', 'http://host', 'http://host/')
 
662
        #test('.', 'http://host', 'http://host/')
777
663
        test('http://host/', 'http://host', 'http://host/')
778
 
        # test('.', 'http://host/', 'http://host')
 
664
        #test('.', 'http://host/', 'http://host')
779
665
        test('http://host', 'http://host/', 'http://host')
780
666
 
781
667
        # On Windows file:///C:/path/to and file:///D:/other/path
783
669
        if sys.platform == 'win32':
784
670
            # on the same drive
785
671
            test('../../other/path',
786
 
                 'file:///C:/path/to', 'file:///C:/other/path')
787
 
            # ~next two tests is failed, i.e. urlutils.relative_url expects
788
 
            # ~to see normalized file URLs?
789
 
            # ~test('../../other/path',
790
 
            # ~    'file:///C:/path/to', 'file:///c:/other/path')
791
 
            # ~test('../../other/path',
792
 
            # ~    'file:///C:/path/to', 'file:///C|/other/path')
 
672
                'file:///C:/path/to', 'file:///C:/other/path')
 
673
            #~next two tests is failed, i.e. urlutils.relative_url expects
 
674
            #~to see normalized file URLs?
 
675
            #~test('../../other/path',
 
676
            #~    'file:///C:/path/to', 'file:///c:/other/path')
 
677
            #~test('../../other/path',
 
678
            #~    'file:///C:/path/to', 'file:///C|/other/path')
793
679
 
794
680
            # check UNC paths too
795
681
            test('../../other/path',
796
 
                 'file://HOST/base/path/to', 'file://HOST/base/other/path')
 
682
                'file://HOST/base/path/to', 'file://HOST/base/other/path')
797
683
            # on different drives
798
684
            test('file:///D:/other/path',
799
 
                 'file:///C:/path/to', 'file:///D:/other/path')
 
685
                'file:///C:/path/to', 'file:///D:/other/path')
800
686
            # TODO: strictly saying in UNC path //HOST/base is full analog
801
687
            # of drive letter for hard disk, and this situation is also
802
688
            # should be exception from rules. [bialix 20071221]
803
689
 
804
690
 
805
691
class TestCwdToURL(TestCaseInTempDir):
806
 
    """Test that local_path_to_url works based on the cwd"""
 
692
    """Test that local_path_to_url works base on the cwd"""
807
693
 
808
694
    def test_dot(self):
809
695
        # This test will fail if getcwd is not ascii
814
700
        self.assertEndsWith(url, '/mytest')
815
701
 
816
702
    def test_non_ascii(self):
 
703
        if win32utils.winver == 'Windows 98':
 
704
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
 
705
 
817
706
        try:
818
707
            os.mkdir(u'dod\xe9')
819
708
        except UnicodeError:
859
748
        self.assertEqual('/foo', result)
860
749
 
861
750
    def test_different_ports(self):
862
 
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
 
751
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
863
752
                              'foo', 'http://bar:80', 'http://bar:81')
864
753
        self.assertEqual(str(e), "URLs differ by more than path:"
865
754
                         " 'http://bar:80' and 'http://bar:81'")
866
755
 
867
756
    def test_different_hosts(self):
868
 
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
 
757
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
869
758
                              'foo', 'http://bar', 'http://baz')
870
759
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
871
760
                         " and 'http://baz'")
872
761
 
873
762
    def test_different_protocol(self):
874
 
        e = self.assertRaises(urlutils.InvalidRebaseURLs, urlutils.rebase_url,
 
763
        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,
875
764
                              'foo', 'http://bar', 'ftp://bar')
876
765
        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"
877
766
                         " and 'ftp://bar'")
878
767
 
879
768
    def test_rebase_success(self):
880
769
        self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',
881
 
                                                       'http://baz/qux'))
882
 
        self.assertEqual(
883
 
            'qux/bar',
884
 
            urlutils.rebase_url('bar', 'http://baz/qux', 'http://baz/'))
885
 
        self.assertEqual(
886
 
            '.', urlutils.rebase_url('foo', 'http://bar/', 'http://bar/foo/'))
887
 
        self.assertEqual(
888
 
            'qux/bar',
889
 
            urlutils.rebase_url('../bar', 'http://baz/qux/foo', 'http://baz/'))
 
770
                         'http://baz/qux'))
 
771
        self.assertEqual('qux/bar', urlutils.rebase_url('bar',
 
772
                         'http://baz/qux', 'http://baz/'))
 
773
        self.assertEqual('.', urlutils.rebase_url('foo',
 
774
                         'http://bar/', 'http://bar/foo/'))
 
775
        self.assertEqual('qux/bar', urlutils.rebase_url('../bar',
 
776
                         'http://baz/qux/foo', 'http://baz/'))
890
777
 
891
778
    def test_determine_relative_path(self):
892
779
        self.assertEqual('../../baz/bar',
893
780
                         urlutils.determine_relative_path(
894
 
                             '/qux/quxx', '/baz/bar'))
 
781
                         '/qux/quxx', '/baz/bar'))
895
782
        self.assertEqual('..',
896
783
                         urlutils.determine_relative_path(
897
 
                             '/bar/baz', '/bar'))
 
784
                         '/bar/baz', '/bar'))
898
785
        self.assertEqual('baz',
899
786
                         urlutils.determine_relative_path(
900
 
                             '/bar', '/bar/baz'))
 
787
                         '/bar', '/bar/baz'))
901
788
        self.assertEqual('.', urlutils.determine_relative_path(
902
789
                         '/bar', '/bar'))
903
790
 
904
791
 
905
792
class TestParseURL(TestCase):
906
793
 
907
 
    def test_parse_simple(self):
908
 
        parsed = urlutils.parse_url('http://example.com:80/one')
909
 
        self.assertEqual(('http', None, None, 'example.com', 80, '/one'),
910
 
                         parsed)
911
 
 
912
 
    def test_ipv6(self):
913
 
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
914
 
        self.assertEqual(('http', None, None, '1:2:3::40', None, '/one'),
915
 
                         parsed)
916
 
 
917
 
    def test_ipv6_port(self):
918
 
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
919
 
        self.assertEqual(('http', None, None, '1:2:3::40', 80, '/one'),
920
 
                         parsed)
921
 
 
922
 
 
923
 
class TestURL(TestCase):
924
 
 
925
 
    def test_parse_simple(self):
926
 
        parsed = urlutils.URL.from_string('http://example.com:80/one')
927
 
        self.assertEqual('http', parsed.scheme)
928
 
        self.assertIs(None, parsed.user)
929
 
        self.assertIs(None, parsed.password)
930
 
        self.assertEqual('example.com', parsed.host)
931
 
        self.assertEqual(80, parsed.port)
932
 
        self.assertEqual('/one', parsed.path)
933
 
 
934
 
    def test_ipv6(self):
935
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
936
 
        self.assertEqual('http', parsed.scheme)
937
 
        self.assertIs(None, parsed.port)
938
 
        self.assertIs(None, parsed.user)
939
 
        self.assertIs(None, parsed.password)
940
 
        self.assertEqual('1:2:3::40', parsed.host)
941
 
        self.assertEqual('/one', parsed.path)
942
 
 
943
 
    def test_ipv6_port(self):
944
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
945
 
        self.assertEqual('http', parsed.scheme)
946
 
        self.assertEqual('1:2:3::40', parsed.host)
947
 
        self.assertIs(None, parsed.user)
948
 
        self.assertIs(None, parsed.password)
949
 
        self.assertEqual(80, parsed.port)
950
 
        self.assertEqual('/one', parsed.path)
951
 
 
952
 
    def test_quoted(self):
953
 
        parsed = urlutils.URL.from_string(
954
 
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
955
 
        self.assertEqual(parsed.quoted_host, 'ex%41mple.com')
956
 
        self.assertEqual(parsed.host, 'exAmple.com')
957
 
        self.assertEqual(parsed.port, 2222)
958
 
        self.assertEqual(parsed.quoted_user, 'ro%62ey')
959
 
        self.assertEqual(parsed.user, 'robey')
960
 
        self.assertEqual(parsed.quoted_password, 'h%40t')
961
 
        self.assertEqual(parsed.password, 'h@t')
962
 
        self.assertEqual(parsed.path, '/path')
963
 
 
964
 
    def test_eq(self):
965
 
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
966
 
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
967
 
        self.assertEqual(parsed1, parsed2)
968
 
        self.assertEqual(parsed1, parsed1)
969
 
        parsed2.path = '/two'
970
 
        self.assertNotEqual(parsed1, parsed2)
971
 
 
972
 
    def test_repr(self):
973
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
974
 
        self.assertEqual(
975
 
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
976
 
            repr(parsed))
977
 
 
978
 
    def test_str(self):
979
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
980
 
        self.assertEqual('http://[1:2:3::40]:80/one', str(parsed))
981
 
 
982
 
    def test__combine_paths(self):
983
 
        combine = urlutils.URL._combine_paths
984
 
        self.assertEqual('/home/sarah/project/foo',
985
 
                         combine('/home/sarah', 'project/foo'))
986
 
        self.assertEqual('/etc',
987
 
                         combine('/home/sarah', '../../etc'))
988
 
        self.assertEqual('/etc',
989
 
                         combine('/home/sarah', '../../../etc'))
990
 
        self.assertEqual('/etc',
991
 
                         combine('/home/sarah', '/etc'))
992
 
 
993
 
    def test_clone(self):
994
 
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
995
 
        url1 = url.clone("two")
996
 
        self.assertEqual("/one/two", url1.path)
997
 
        url2 = url.clone("/two")
998
 
        self.assertEqual("/two", url2.path)
999
 
        url3 = url.clone()
1000
 
        self.assertIsNot(url, url3)
1001
 
        self.assertEqual(url, url3)
1002
 
 
1003
 
    def test_parse_empty_port(self):
1004
 
        parsed = urlutils.URL.from_string('http://example.com:/one')
1005
 
        self.assertEqual('http', parsed.scheme)
1006
 
        self.assertIs(None, parsed.user)
1007
 
        self.assertIs(None, parsed.password)
1008
 
        self.assertEqual('example.com', parsed.host)
1009
 
        self.assertIs(None, parsed.port)
1010
 
        self.assertEqual('/one', parsed.path)
1011
 
 
1012
 
 
1013
 
class TestFileRelpath(TestCase):
1014
 
 
1015
 
    # GZ 2011-11-18: A way to override all path handling functions to one
1016
 
    #                platform or another for testing would be nice.
1017
 
 
1018
 
    def _with_posix_paths(self):
1019
 
        self.overrideAttr(urlutils, "local_path_from_url",
1020
 
                          urlutils._posix_local_path_from_url)
1021
 
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH", len("file:///"))
1022
 
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
1023
 
        self.overrideAttr(osutils, "abspath", osutils._posix_abspath)
1024
 
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
1025
 
        self.overrideAttr(osutils, "pathjoin", osutils.posixpath.join)
1026
 
        self.overrideAttr(osutils, "split", osutils.posixpath.split)
1027
 
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 1)
1028
 
 
1029
 
    def _with_win32_paths(self):
1030
 
        self.overrideAttr(urlutils, "local_path_from_url",
1031
 
                          urlutils._win32_local_path_from_url)
1032
 
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH",
1033
 
                          urlutils.WIN32_MIN_ABS_FILEURL_LENGTH)
1034
 
        self.overrideAttr(osutils, "abspath", osutils._win32_abspath)
1035
 
        self.overrideAttr(osutils, "normpath", osutils._win32_normpath)
1036
 
        self.overrideAttr(osutils, "pathjoin", osutils._win32_pathjoin)
1037
 
        self.overrideAttr(osutils, "split", osutils.ntpath.split)
1038
 
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 3)
1039
 
 
1040
 
    def test_same_url_posix(self):
1041
 
        self._with_posix_paths()
1042
 
        self.assertEqual("",
1043
 
                         urlutils.file_relpath("file:///a", "file:///a"))
1044
 
        self.assertEqual("",
1045
 
                         urlutils.file_relpath("file:///a", "file:///a/"))
1046
 
        self.assertEqual("",
1047
 
                         urlutils.file_relpath("file:///a/", "file:///a"))
1048
 
 
1049
 
    def test_same_url_win32(self):
1050
 
        self._with_win32_paths()
1051
 
        self.assertEqual("",
1052
 
                         urlutils.file_relpath("file:///A:/", "file:///A:/"))
1053
 
        self.assertEqual("",
1054
 
                         urlutils.file_relpath("file:///A|/", "file:///A:/"))
1055
 
        self.assertEqual(
1056
 
            "", urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
1057
 
        self.assertEqual(
1058
 
            "", urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
1059
 
        self.assertEqual(
1060
 
            "", urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
1061
 
 
1062
 
    def test_child_posix(self):
1063
 
        self._with_posix_paths()
1064
 
        self.assertEqual(
1065
 
            "b", urlutils.file_relpath("file:///a", "file:///a/b"))
1066
 
        self.assertEqual(
1067
 
            "b", urlutils.file_relpath("file:///a/", "file:///a/b"))
1068
 
        self.assertEqual(
1069
 
            "b/c", urlutils.file_relpath("file:///a", "file:///a/b/c"))
1070
 
 
1071
 
    def test_child_win32(self):
1072
 
        self._with_win32_paths()
1073
 
        self.assertEqual(
1074
 
            "b", urlutils.file_relpath("file:///A:/", "file:///A:/b"))
1075
 
        self.assertEqual(
1076
 
            "b", urlutils.file_relpath("file:///A|/", "file:///A:/b"))
1077
 
        self.assertEqual(
1078
 
            "c", urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
1079
 
        self.assertEqual(
1080
 
            "c", urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
1081
 
        self.assertEqual(
1082
 
            "c/d", urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
1083
 
 
1084
 
    def test_sibling_posix(self):
1085
 
        self._with_posix_paths()
1086
 
        self.assertRaises(
1087
 
            PathNotChild,
1088
 
            urlutils.file_relpath, "file:///a/b", "file:///a/c")
1089
 
        self.assertRaises(
1090
 
            PathNotChild,
1091
 
            urlutils.file_relpath, "file:///a/b/", "file:///a/c")
1092
 
        self.assertRaises(
1093
 
            PathNotChild,
1094
 
            urlutils.file_relpath, "file:///a/b/", "file:///a/c/")
1095
 
 
1096
 
    def test_sibling_win32(self):
1097
 
        self._with_win32_paths()
1098
 
        self.assertRaises(
1099
 
            PathNotChild,
1100
 
            urlutils.file_relpath, "file:///A:/b", "file:///A:/c")
1101
 
        self.assertRaises(
1102
 
            PathNotChild,
1103
 
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c")
1104
 
        self.assertRaises(
1105
 
            PathNotChild,
1106
 
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c/")
1107
 
 
1108
 
    def test_parent_posix(self):
1109
 
        self._with_posix_paths()
1110
 
        self.assertRaises(PathNotChild,
1111
 
                          urlutils.file_relpath, "file:///a/b", "file:///a")
1112
 
        self.assertRaises(PathNotChild,
1113
 
                          urlutils.file_relpath, "file:///a/b", "file:///a/")
1114
 
 
1115
 
    def test_parent_win32(self):
1116
 
        self._with_win32_paths()
1117
 
        self.assertRaises(
1118
 
            PathNotChild,
1119
 
            urlutils.file_relpath, "file:///A:/b", "file:///A:/")
1120
 
        self.assertRaises(
1121
 
            PathNotChild,
1122
 
            urlutils.file_relpath, "file:///A:/b/c", "file:///A:/b")
1123
 
 
1124
 
 
1125
 
class QuoteTests(TestCase):
1126
 
 
1127
 
    def test_quote(self):
1128
 
        self.assertEqual('abc%20def', urlutils.quote('abc def'))
1129
 
        self.assertEqual('abc%2Fdef', urlutils.quote('abc/def', safe=''))
1130
 
        self.assertEqual('abc/def', urlutils.quote('abc/def', safe='/'))
1131
 
 
1132
 
    def test_quote_tildes(self):
1133
 
        # Whether ~ is quoted by default depends on the python version
1134
 
        if sys.version_info[:2] >= (3, 7):
1135
 
            # https://docs.python.org/3/whatsnew/3.7.html#urllib-parse
1136
 
            self.assertEqual('~foo', urlutils.quote('~foo'))
1137
 
        else:
1138
 
            self.assertEqual('%7Efoo', urlutils.quote('~foo'))
1139
 
        self.assertEqual('~foo', urlutils.quote('~foo', safe='/~'))
1140
 
 
1141
 
    def test_unquote(self):
1142
 
        self.assertEqual('%', urlutils.unquote('%25'))
1143
 
        if PY3:
1144
 
            self.assertEqual('\xe5', urlutils.unquote('%C3%A5'))
1145
 
        else:
1146
 
            self.assertEqual('\xc3\xa5', urlutils.unquote('%C3%A5'))
1147
 
        self.assertEqual(u"\xe5", urlutils.unquote(u'\xe5'))
1148
 
 
1149
 
    def test_unquote_to_bytes(self):
1150
 
        self.assertEqual(b'%', urlutils.unquote_to_bytes('%25'))
1151
 
        self.assertEqual(b'\xc3\xa5', urlutils.unquote_to_bytes('%C3%A5'))
 
794
    def test_parse_url(self):
 
795
        self.assertEqual(urlutils.parse_url('http://example.com:80/one'),
 
796
            ('http', None, None, 'example.com', 80, '/one'))
 
797
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]/one'),
 
798
                ('http', None, None, '1:2:3::40', None, '/one'))
 
799
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]:80/one'),
 
800
                ('http', None, None, '1:2:3::40', 80, '/one'))