~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (2414 to 5200.3.1)
• stop comparing with revision 5200.3.1

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')

113

115

        eq('http://host/ab/%C2%B5/%C2%B5',

114

116

            normalize_url(u'http://host/ab/%C2%B5/\xb5'))

115

117

 

116

 

        # Unescape characters that don't need to be escaped

117

 

        eq('http://host/~bob%2525-._',

118

 

                normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))

119

 

        eq('http://host/~bob%2525-._',

120

 

                normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))

121

 

 

122

118

        # Normalize verifies URLs when they are not unicode

123

119

        # (indicating they did not come from the user)

124

120

        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')

225

221

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

226

222

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

227

223

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

228

 

 

 

224

        

229

225

        # Invalid joinings

230

226

        # Cannot go above root

231

227

        # Implicitly at root:

263

259

 

264

260

        # Test joining to a path with a trailing slash

265

261

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

266

 

 

 

262

        

267

263

        # Invalid joinings

268

264

        # Cannot go above root

269

265

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

289

285

            raise TestSkipped("local encoding cannot handle unicode")

290

286

 

291

287

        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

292

 

        self.assertFalse(isinstance(result, unicode))

293

288

 

294

289

    def test_posix_local_path_from_url(self):

295

290

        from_url = urlutils._posix_local_path_from_url

299

294

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

300

295

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

301

296

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

302

 

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

303

 

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

304

297

 

305

298

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

306

 

        self.assertRaises(

307

 

            InvalidURL, from_url,

308

 

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

309

299

 

310

300

    def test_win32_local_path_to_url(self):

311

301

        to_url = urlutils._win32_local_path_to_url

320

310

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

321

311

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

322

312

 

323

 

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

324

 

 

325

313

        try:

326

314

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

327

315

        except UnicodeError:

328

316

            raise TestSkipped("local encoding cannot handle unicode")

329

317

 

330

318

        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

331

 

        self.assertFalse(isinstance(result, unicode))

332

319

 

333

320

    def test_win32_unc_path_to_url(self):

334

321

        to_url = urlutils._win32_local_path_to_url

343

330

            raise TestSkipped("local encoding cannot handle unicode")

344

331

 

345

332

        self.assertEqual('file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

346

 

        self.assertFalse(isinstance(result, unicode))

 

333

 

347

334

 

348

335

    def test_win32_local_path_from_url(self):

349

336

        from_url = urlutils._win32_local_path_from_url

353

340

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

354

341

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

355

342

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

356

 

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

357

343

 

358

344

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

359

345

        # Not a valid _win32 url, no drive letter

499

485

    def test_escape(self):

500

486

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

501

487

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

502

 

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

503

 

 

504

 

    def test_escape_tildes(self):

505

 

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

506

488

 

507

489

    def test_unescape(self):

508

490

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

520

502

        def test(expected, base, other):

521

503

            result = urlutils.relative_url(base, other)

522

504

            self.assertEqual(expected, result)

523

 

 

 

505

            

524

506

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

525

507

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

526

508

                    'http://entirely/different')

535

517

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

536

518

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

537

519

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

538

 

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

 

520

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

539

521

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

540

522

        # relative_url should preserve a trailing slash

541

523

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

553

535

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

554

536

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

555

537

 

556

 

        # On Windows file:///C:/path/to and file:///D:/other/path

557

 

        # should not use relative url over the non-existent '/' directory.

558

 

        if sys.platform == 'win32':

559

 

            # on the same drive

560

 

            test('../../other/path',

561

 

                'file:///C:/path/to', 'file:///C:/other/path')

562

 

            #~next two tests is failed, i.e. urlutils.relative_url expects

563

 

            #~to see normalized file URLs?

564

 

            #~test('../../other/path',

565

 

            #~    'file:///C:/path/to', 'file:///c:/other/path')

566

 

            #~test('../../other/path',

567

 

            #~    'file:///C:/path/to', 'file:///C|/other/path')

568

 

 

569

 

            # check UNC paths too

570

 

            test('../../other/path',

571

 

                'file://HOST/base/path/to', 'file://HOST/base/other/path')

572

 

            # on different drives

573

 

            test('file:///D:/other/path',

574

 

                'file:///C:/path/to', 'file:///D:/other/path')

575

 

            # TODO: strictly saying in UNC path //HOST/base is full analog

576

 

            # of drive letter for hard disk, and this situation is also

577

 

            # should be exception from rules. [bialix 20071221]

578

 

 

579

538

 

580

539

class TestCwdToURL(TestCaseInTempDir):

581

540

    """Test that local_path_to_url works base on the cwd"""

599

558

 

600

559

        os.chdir(u'dod\xe9')

601

560

 

602

 

        # On Mac OSX this directory is actually:

 

561

        # On Mac OSX this directory is actually: 

603

562

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

604

 

        # but we should normalize it back to

 

563

        # but we should normalize it back to 

605

564

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

606

565

        url = urlutils.local_path_to_url('.')

607

566

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

608

 

 

609

 

 

610

 

class TestDeriveToLocation(TestCase):

611

 

    """Test that the mapping of FROM_LOCATION to TO_LOCATION works."""

612

 

 

613

 

    def test_to_locations_derived_from_paths(self):

614

 

        derive = urlutils.derive_to_location

615

 

        self.assertEqual("bar", derive("bar"))

616

 

        self.assertEqual("bar", derive("../bar"))

617

 

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

618

 

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

619

 

        self.assertEqual("bar", derive("c:bar"))

620

 

 

621

 

    def test_to_locations_derived_from_urls(self):

622

 

        derive = urlutils.derive_to_location

623

 

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

624

 

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

625

 

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

626

 

 

627

 

 

628

 

class TestRebaseURL(TestCase):

629

 

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

630

 

 

631

 

    def test_non_relative(self):

632

 

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

633

 

                                     'file://foo/bar')

634

 

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

635

 

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

636

 

                                     'file://foo/bar')

637

 

        self.assertEqual('/foo', result)

638

 

 

639

 

    def test_different_ports(self):

640

 

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

641

 

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

642

 

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

643

 

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

644

 

 

645

 

    def test_different_hosts(self):

646

 

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

647

 

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

648

 

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

649

 

                         " and 'http://baz'")

650

 

 

651

 

    def test_different_protocol(self):

652

 

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

653

 

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

654

 

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

655

 

                         " and 'ftp://bar'")

656

 

 

657

 

    def test_rebase_success(self):

658

 

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

659

 

                         'http://baz/qux'))

660

 

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

661

 

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

662

 

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

663

 

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

664

 

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

665

 

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

666

 

 

667

 

    def test_determine_relative_path(self):

668

 

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

669

 

                         urlutils.determine_relative_path(

670

 

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

671

 

        self.assertEqual('..',

672

 

                         urlutils.determine_relative_path(

673

 

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

674

 

        self.assertEqual('baz',

675

 

                         urlutils.determine_relative_path(

676

 

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

677

 

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

678

 

                         '/bar', '/bar'))

679

 

 

680

 

 

681

 

class TestParseURL(TestCase):

682

 

 

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'))

• Older »

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