~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

• browse files at revision 3517.2.3
• compare with another revision
• download diff
• download tarball
• view history from revision 3517.2.3

• reverse the comparison (3517.2.3 to 5718.8.16)
• stop comparing with revision 5718.8.16

Show diffs side-by-side

added

removed

bzrlib/tests/test_urlutils.py

1

 

# Copyright (C) 2006-2010 Canonical Ltd

 

1

# Copyright (C) 2005 Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

12

12

#

13

13

# You should have received a copy of the GNU General Public License

14

14

# along with this program; if not, write to the Free Software

15

 

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 

15

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

16

16

 

17

17

"""Tests for the urlutils wrapper."""

18

18

 

19

19

import os

 

20

import re

20

21

import sys

21

22

 

22

23

from bzrlib import osutils, urlutils, win32utils

23

 

from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs

 

24

import bzrlib

 

25

from bzrlib.errors import InvalidURL, InvalidURLJoin

24

26

from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped

25

27

 

26

28

 

27

29

class TestUrlToPath(TestCase):

28

 

 

 

30

    

29

31

    def test_basename(self):

30

32

        # bzrlib.urlutils.basename

31

33

        # Test bzrlib.urlutils.split()

80

82

 

81

83

        # Local paths are assumed to *not* be escaped at all

82

84

        try:

83

 

            u'uni/\xb5'.encode(osutils.get_user_encoding())

 

85

            u'uni/\xb5'.encode(bzrlib.user_encoding)

84

86

        except UnicodeError:

85

 

            # locale cannot handle unicode

 

87

            # locale cannot handle unicode 

86

88

            pass

87

89

        else:

88

90

            norm_file('uni/%C2%B5', u'uni/\xb5')

156

158

        # Weird stuff

157

159

        # Can't have slashes or colons in the scheme

158

160

        test_one('/path/to/://foo', None)

159

 

        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))

 

161

        test_one('path:path://foo', None)

160

162

        # Must have more than one character for scheme

161

163

        test_one('C://foo', None)

162

164

        test_one('ab://foo', ('ab', 'foo'))

195

197

            dirname('path/to/foo/', exclude_trailing_slash=False))

196

198

        self.assertEqual('path/..', dirname('path/../foo'))

197

199

        self.assertEqual('../path', dirname('../path/foo'))

198

 

    

199

 

    def test_is_url(self):

200

 

        self.assertTrue(urlutils.is_url('http://foo/bar'))

201

 

        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))

202

 

        self.assertTrue(urlutils.is_url('lp:foo/bar'))

203

 

        self.assertTrue(urlutils.is_url('file:///foo/bar'))

204

 

        self.assertFalse(urlutils.is_url(''))

205

 

        self.assertFalse(urlutils.is_url('foo'))

206

 

        self.assertFalse(urlutils.is_url('foo/bar'))

207

 

        self.assertFalse(urlutils.is_url('/foo'))

208

 

        self.assertFalse(urlutils.is_url('/foo/bar'))

209

 

        self.assertFalse(urlutils.is_url('C:/'))

210

 

        self.assertFalse(urlutils.is_url('C:/foo'))

211

 

        self.assertFalse(urlutils.is_url('C:/foo/bar'))

212

200

 

213

201

    def test_join(self):

214

202

        def test(expected, *args):

224

212

        test('http://foo/bar/baz', 'http://foo', 'bar/baz')

225

213

        test('http://foo/baz', 'http://foo', 'bar/../baz')

226

214

        test('http://foo/baz', 'http://foo/bar/', '../baz')

227

 

        test('lp:foo/bar', 'lp:foo', 'bar')

228

 

        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')

229

215

 

230

216

        # Absolute paths

231

217

        test('http://foo', 'http://foo') # abs url with nothing is preserved.

235

221

        test('http://bar/', 'http://foo', 'http://bar/')

236

222

        test('http://bar/a', 'http://foo', 'http://bar/a')

237

223

        test('http://bar/a/', 'http://foo', 'http://bar/a/')

238

 

        test('lp:bar', 'http://foo', 'lp:bar')

239

 

        test('lp:bar', 'lp:foo', 'lp:bar')

240

 

        test('file:///stuff', 'lp:foo', 'file:///stuff')

241

224

 

242

225

        # From a base path

243

226

        test('file:///foo', 'file:///', 'foo')

244

227

        test('file:///bar/foo', 'file:///bar/', 'foo')

245

228

        test('http://host/foo', 'http://host/', 'foo')

246

229

        test('http://host/', 'http://host', '')

247

 

 

 

230

        

248

231

        # Invalid joinings

249

232

        # Cannot go above root

250

233

        # Implicitly at root:

282

265

 

283

266

        # Test joining to a path with a trailing slash

284

267

        test('foo/bar', 'foo/', 'bar')

285

 

 

 

268

        

286

269

        # Invalid joinings

287

270

        # Cannot go above root

288

271

        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')

289

272

        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')

290

273

        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')

291

274

 

292

 

    def test_join_segment_parameters_raw(self):

293

 

        join_segment_parameters_raw = urlutils.join_segment_parameters_raw

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",

304

 

            join_segment_parameters_raw("/somedir,exist=some/path",

305

 

                "bla", "bar"))

306

 

        self.assertRaises(TypeError, join_segment_parameters_raw, 

307

 

            "/somepath", 42)

308

 

 

309

 

    def test_join_segment_parameters(self):

310

 

        join_segment_parameters = urlutils.join_segment_parameters

311

 

        self.assertEquals("/somedir/path", 

312

 

            join_segment_parameters("/somedir/path", {}))

313

 

        self.assertEquals("/somedir/path,key1=val1", 

314

 

            join_segment_parameters("/somedir/path", {"key1": "val1"}))

315

 

        self.assertRaises(InvalidURLJoin,

316

 

            join_segment_parameters, "/somedir/path",

317

 

            {"branch": "brr,brr,brr"})

318

 

        self.assertRaises(InvalidURLJoin,

319

 

            join_segment_parameters, "/somedir/path", {"key1=val1": "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",

333

 

            join_segment_parameters("/,key1=val1", {"key2": "val2"}))

334

 

        self.assertRaises(TypeError,

335

 

            join_segment_parameters, "/,key1=val1", {"foo": 42})

336

 

 

337

275

    def test_function_type(self):

338

276

        if sys.platform == 'win32':

339

277

            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)

363

301

            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))

364

302

        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',

365

303

            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))

366

 

        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',

367

 

            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))

368

304

 

369

305

        self.assertRaises(InvalidURL, from_url, '/path/to/foo')

370

 

        self.assertRaises(

371

 

            InvalidURL, from_url,

372

 

            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')

373

306

 

374

307

    def test_win32_local_path_to_url(self):

375

308

        to_url = urlutils._win32_local_path_to_url

384

317

        self.assertEqual('file:///C:/path/to/f%20oo',

385

318

            to_url('C:/path/to/f oo'))

386

319

 

387

 

        self.assertEqual('file:///', to_url('/'))

388

 

 

389

320

        try:

390

321

            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')

391

322

        except UnicodeError:

417

348

            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))

418

349

        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',

419

350

            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))

420

 

        self.assertEqual('/', from_url('file:///'))

421

351

 

422

 

        self.assertRaises(InvalidURL, from_url, 'file:///C:')

423

 

        self.assertRaises(InvalidURL, from_url, 'file:///c')

424

352

        self.assertRaises(InvalidURL, from_url, '/path/to/foo')

425

353

        # Not a valid _win32 url, no drive letter

426

354

        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')

478

406

        self.assertEqual(('path/..', 'foo'), split('path/../foo'))

479

407

        self.assertEqual(('../path', 'foo'), split('../path/foo'))

480

408

 

481

 

    def test_split_segment_parameters_raw(self):

482

 

        split_segment_parameters_raw = urlutils.split_segment_parameters_raw

483

 

        self.assertEquals(("/some/path", []),

484

 

            split_segment_parameters_raw("/some/path"))

485

 

        self.assertEquals(("/some/path", ["tip"]),

486

 

            split_segment_parameters_raw("/some/path,tip"))

487

 

        self.assertEquals(("/some,dir/path", ["tip"]),

488

 

            split_segment_parameters_raw("/some,dir/path,tip"))

489

 

        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),

490

 

            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))

491

 

        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),

492

 

            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))

493

 

        self.assertEquals(("/", ["key1=val1"]),

494

 

            split_segment_parameters_raw(",key1=val1"))

495

 

        self.assertEquals(("foo/", ["key1=val1"]),

496

 

            split_segment_parameters_raw("foo/,key1=val1"))

497

 

        self.assertEquals(("foo/base,la=bla/other/elements", []),

498

 

            split_segment_parameters_raw("foo/base,la=bla/other/elements"))

499

 

        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),

500

 

            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))

501

 

 

502

 

    def test_split_segment_parameters(self):

503

 

        split_segment_parameters = urlutils.split_segment_parameters

504

 

        self.assertEquals(("/some/path", {}),

505

 

            split_segment_parameters("/some/path"))

506

 

        self.assertEquals(("/some/path", {"branch": "tip"}),

507

 

            split_segment_parameters("/some/path,branch=tip"))

508

 

        self.assertEquals(("/some,dir/path", {"branch": "tip"}),

509

 

            split_segment_parameters("/some,dir/path,branch=tip"))

510

 

        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),

511

 

            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))

512

 

        self.assertEquals(("/somedir/path",

513

 

            {"ref": "heads%2Ftip", "key1": "val1"}),

514

 

            split_segment_parameters(

515

 

                "/somedir/path,ref=heads%2Ftip,key1=val1"))

516

 

        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),

517

 

            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))

518

 

        self.assertEquals(("/", {"key1": "val1"}),

519

 

            split_segment_parameters(",key1=val1"))

520

 

        self.assertEquals(("foo/", {"key1": "val1"}),

521

 

            split_segment_parameters("foo/,key1=val1"))

522

 

        self.assertEquals(("foo/base,key1=val1/other/elements", {}),

523

 

            split_segment_parameters("foo/base,key1=val1/other/elements"))

524

 

        self.assertEquals(("foo/base,key1=val1/other/elements",

525

 

            {"key2": "val2"}), split_segment_parameters(

526

 

                "foo/base,key1=val1/other/elements,key2=val2"))

527

 

 

528

409

    def test_win32_strip_local_trailing_slash(self):

529

410

        strip = urlutils._win32_strip_local_trailing_slash

530

411

        self.assertEqual('file://', strip('file://'))

614

495

        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))

615

496

        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))

616

497

 

617

 

    def test_escape_tildes(self):

618

 

        self.assertEqual('~foo', urlutils.escape('~foo'))

619

 

 

620

498

    def test_unescape(self):

621

499

        self.assertEqual('%', urlutils.unescape('%25'))

622

500

        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))

633

511

        def test(expected, base, other):

634

512

            result = urlutils.relative_url(base, other)

635

513

            self.assertEqual(expected, result)

636

 

 

 

514

            

637

515

        test('a', 'http://host/', 'http://host/a')

638

516

        test('http://entirely/different', 'sftp://host/branch',

639

517

                    'http://entirely/different')

648

526

                    'sftp://host/home/jelmer/branch/2b')

649

527

        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',

650

528

                    'http://host/home/jelmer/branch/feature/%2b')

651

 

        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',

 

529

        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/', 

652

530

                    'http://host/home/jelmer/branch/feature/2b')

653

531

        # relative_url should preserve a trailing slash

654

532

        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',

712

590

 

713

591

        os.chdir(u'dod\xe9')

714

592

 

715

 

        # On Mac OSX this directory is actually:

 

593

        # On Mac OSX this directory is actually: 

716

594

        #   u'/dode\u0301' => '/dode\xcc\x81

717

 

        # but we should normalize it back to

 

595

        # but we should normalize it back to 

718

596

        #   u'/dod\xe9' => '/dod\xc3\xa9'

719

597

        url = urlutils.local_path_to_url('.')

720

598

        self.assertEndsWith(url, '/dod%C3%A9')

736

614

        self.assertEqual("bar", derive("http://foo/bar"))

737

615

        self.assertEqual("bar", derive("bzr+ssh://foo/bar"))

738

616

        self.assertEqual("foo-bar", derive("lp:foo-bar"))

739

 

 

740

 

 

741

 

class TestRebaseURL(TestCase):

742

 

    """Test the behavior of rebase_url."""

743

 

 

744

 

    def test_non_relative(self):

745

 

        result = urlutils.rebase_url('file://foo', 'file://foo',

746

 

                                     'file://foo/bar')

747

 

        self.assertEqual('file://foo', result)

748

 

        result = urlutils.rebase_url('/foo', 'file://foo',

749

 

                                     'file://foo/bar')

750

 

        self.assertEqual('/foo', result)

751

 

 

752

 

    def test_different_ports(self):

753

 

        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,

754

 

                              'foo', 'http://bar:80', 'http://bar:81')

755

 

        self.assertEqual(str(e), "URLs differ by more than path:"

756

 

                         " 'http://bar:80' and 'http://bar:81'")

757

 

 

758

 

    def test_different_hosts(self):

759

 

        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,

760

 

                              'foo', 'http://bar', 'http://baz')

761

 

        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"

762

 

                         " and 'http://baz'")

763

 

 

764

 

    def test_different_protocol(self):

765

 

        e = self.assertRaises(InvalidRebaseURLs, urlutils.rebase_url,

766

 

                              'foo', 'http://bar', 'ftp://bar')

767

 

        self.assertEqual(str(e), "URLs differ by more than path: 'http://bar'"

768

 

                         " and 'ftp://bar'")

769

 

 

770

 

    def test_rebase_success(self):

771

 

        self.assertEqual('../bar', urlutils.rebase_url('bar', 'http://baz/',

772

 

                         'http://baz/qux'))

773

 

        self.assertEqual('qux/bar', urlutils.rebase_url('bar',

774

 

                         'http://baz/qux', 'http://baz/'))

775

 

        self.assertEqual('.', urlutils.rebase_url('foo',

776

 

                         'http://bar/', 'http://bar/foo/'))

777

 

        self.assertEqual('qux/bar', urlutils.rebase_url('../bar',

778

 

                         'http://baz/qux/foo', 'http://baz/'))

779

 

 

780

 

    def test_determine_relative_path(self):

781

 

        self.assertEqual('../../baz/bar',

782

 

                         urlutils.determine_relative_path(

783

 

                         '/qux/quxx', '/baz/bar'))

784

 

        self.assertEqual('..',

785

 

                         urlutils.determine_relative_path(

786

 

                         '/bar/baz', '/bar'))

787

 

        self.assertEqual('baz',

788

 

                         urlutils.determine_relative_path(

789

 

                         '/bar', '/bar/baz'))

790

 

        self.assertEqual('.', urlutils.determine_relative_path(

791

 

                         '/bar', '/bar'))

792

 

 

793

 

 

794

 

class TestParseURL(TestCase):

795

 

 

796

 

    def test_parse_url(self):

797

 

        self.assertEqual(urlutils.parse_url('http://example.com:80/one'),

798

 

            ('http', None, None, 'example.com', 80, '/one'))

799

 

        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]/one'),

800

 

                ('http', None, None, '1:2:3::40', None, '/one'))

801

 

        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]:80/one'),

802

 

                ('http', None, None, '1:2:3::40', 80, '/one'))

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1