~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (2242 to 5200.1.2)
• stop comparing with revision 5200.1.2

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

 

from bzrlib import osutils, urlutils, win32utils

23

 

from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs

 

23

from bzrlib import osutils, urlutils

 

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

201

197

            joined = urlutils.join(*args)

202

198

            self.assertEqual(expected, joined)

203

199

 

 

200

        # Test a single element

 

201

        test('foo', 'foo')

 

202

 

204

203

        # Test relative path joining

205

 

        test('foo', 'foo') # relative fragment with nothing is preserved.

206

204

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

207

205

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

208

206

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

209

207

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

210

208

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

211

209

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

212

 

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

213

210

 

214

211

        # Absolute paths

215

 

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

216

212

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

217

213

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

218

214

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

219

 

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

220

 

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

221

 

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

222

215

 

223

216

        # From a base path

224

217

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

225

218

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

226

219

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

227

220

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

228

 

 

 

221

        

229

222

        # Invalid joinings

230

223

        # Cannot go above root

231

 

        # Implicitly at root:

232

224

        self.assertRaises(InvalidURLJoin, urlutils.join,

233

225

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

234

 

        self.assertRaises(InvalidURLJoin, urlutils.join,

235

 

                'http://foo', '/..')

236

 

        # Joining from a path explicitly under the root.

237

 

        self.assertRaises(InvalidURLJoin, urlutils.join,

238

 

                'http://foo/a', '../../b')

239

 

 

240

 

    def test_joinpath(self):

241

 

        def test(expected, *args):

242

 

            joined = urlutils.joinpath(*args)

243

 

            self.assertEqual(expected, joined)

244

 

 

245

 

        # Test a single element

246

 

        test('foo', 'foo')

247

 

 

248

 

        # Test relative path joining

249

 

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

250

 

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

251

 

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

252

 

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

253

 

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

254

 

 

255

 

        # Test joining to an absolute path

256

 

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

257

 

        test('/foo', '/foo', '.')

258

 

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

259

 

        test('/', '/foo', '..')

260

 

 

261

 

        # Test joining with an absolute path

262

 

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

263

 

 

264

 

        # Test joining to a path with a trailing slash

265

 

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

266

 

 

267

 

        # Invalid joinings

268

 

        # Cannot go above root

269

 

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

270

 

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

271

 

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

272

226

 

273

227

    def test_function_type(self):

274

228

        if sys.platform == 'win32':

289

243

            raise TestSkipped("local encoding cannot handle unicode")

290

244

 

291

245

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

292

 

        self.assertFalse(isinstance(result, unicode))

293

246

 

294

247

    def test_posix_local_path_from_url(self):

295

248

        from_url = urlutils._posix_local_path_from_url

299

252

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

300

253

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

301

254

            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

255

 

305

256

        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

257

 

310

258

    def test_win32_local_path_to_url(self):

311

259

        to_url = urlutils._win32_local_path_to_url

320

268

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

321

269

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

322

270

 

323

 

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

324

 

 

325

271

        try:

326

272

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

327

273

        except UnicodeError:

328

274

            raise TestSkipped("local encoding cannot handle unicode")

329

275

 

330

276

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

331

 

        self.assertFalse(isinstance(result, unicode))

332

277

 

333

278

    def test_win32_unc_path_to_url(self):

334

279

        to_url = urlutils._win32_local_path_to_url

343

288

            raise TestSkipped("local encoding cannot handle unicode")

344

289

 

345

290

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

346

 

        self.assertFalse(isinstance(result, unicode))

 

291

 

347

292

 

348

293

    def test_win32_local_path_from_url(self):

349

294

        from_url = urlutils._win32_local_path_from_url

353

298

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

354

299

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

355

300

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

356

 

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

357

301

 

358

302

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

359

303

        # Not a valid _win32 url, no drive letter

499

443

    def test_escape(self):

500

444

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

501

445

        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

446

 

507

447

    def test_unescape(self):

508

448

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

520

460

        def test(expected, base, other):

521

461

            result = urlutils.relative_url(base, other)

522

462

            self.assertEqual(expected, result)

523

 

 

 

463

            

524

464

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

525

465

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

526

466

                    'http://entirely/different')

535

475

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

536

476

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

537

477

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

538

 

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

 

478

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

539

479

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

540

480

        # relative_url should preserve a trailing slash

541

481

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

553

493

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

554

494

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

555

495

 

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

496

 

580

497

class TestCwdToURL(TestCaseInTempDir):

581

498

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

589

506

        self.assertEndsWith(url, '/mytest')

590

507

 

591

508

    def test_non_ascii(self):

592

 

        if win32utils.winver == 'Windows 98':

593

 

            raise TestSkipped('Windows 98 cannot handle unicode filenames')

594

 

 

595

509

        try:

596

510

            os.mkdir(u'dod\xe9')

597

511

        except UnicodeError:

599

513

 

600

514

        os.chdir(u'dod\xe9')

601

515

 

602

 

        # On Mac OSX this directory is actually:

 

516

        # On Mac OSX this directory is actually: 

603

517

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

604

 

        # but we should normalize it back to

 

518

        # but we should normalize it back to 

605

519

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

606

520

        url = urlutils.local_path_to_url('.')

607

521

        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