~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (2363.4.11 to 6017.1.2)
• stop comparing with revision 6017.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

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

156

152

        # Weird stuff

157

153

        # Can't have slashes or colons in the scheme

158

154

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

159

 

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

 

155

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

160

156

        # Must have more than one character for scheme

161

157

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

162

158

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

195

191

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

196

192

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

197

193

        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

194

 

213

195

    def test_join(self):

214

196

        def test(expected, *args):

224

206

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

225

207

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

226

208

        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

209

 

230

210

        # Absolute paths

231

211

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

235

215

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

236

216

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

237

217

        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

218

 

242

219

        # From a base path

243

220

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

244

221

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

245

222

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

246

223

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

247

 

 

 

224

        

248

225

        # Invalid joinings

249

226

        # Cannot go above root

250

227

        # Implicitly at root:

282

259

 

283

260

        # Test joining to a path with a trailing slash

284

261

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

285

 

 

 

262

        

286

263

        # Invalid joinings

287

264

        # Cannot go above root

288

265

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

289

266

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

290

267

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

291

268

 

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

269

    def test_function_type(self):

338

270

        if sys.platform == 'win32':

339

271

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

353

285

            raise TestSkipped("local encoding cannot handle unicode")

354

286

 

355

287

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

356

 

        self.assertFalse(isinstance(result, unicode))

357

288

 

358

289

    def test_posix_local_path_from_url(self):

359

290

        from_url = urlutils._posix_local_path_from_url

363

294

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

364

295

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

365

296

            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

297

 

369

298

        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

299

 

374

300

    def test_win32_local_path_to_url(self):

375

301

        to_url = urlutils._win32_local_path_to_url

384

310

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

385

311

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

386

312

 

387

 

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

388

 

 

389

313

        try:

390

314

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

391

315

        except UnicodeError:

392

316

            raise TestSkipped("local encoding cannot handle unicode")

393

317

 

394

318

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

395

 

        self.assertFalse(isinstance(result, unicode))

396

319

 

397

320

    def test_win32_unc_path_to_url(self):

398

321

        to_url = urlutils._win32_local_path_to_url

407

330

            raise TestSkipped("local encoding cannot handle unicode")

408

331

 

409

332

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

410

 

        self.assertFalse(isinstance(result, unicode))

 

333

 

411

334

 

412

335

    def test_win32_local_path_from_url(self):

413

336

        from_url = urlutils._win32_local_path_from_url

417

340

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

418

341

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

419

342

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

420

 

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

421

343

 

422

 

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

423

 

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

424

344

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

425

345

        # Not a valid _win32 url, no drive letter

426

346

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

478

398

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

479

399

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

480

400

 

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

401

    def test_win32_strip_local_trailing_slash(self):

529

402

        strip = urlutils._win32_strip_local_trailing_slash

530

403

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

612

485

    def test_escape(self):

613

486

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

614

487

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

615

 

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

616

 

 

617

 

    def test_escape_tildes(self):

618

 

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

619

488

 

620

489

    def test_unescape(self):

621

490

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

633

502

        def test(expected, base, other):

634

503

            result = urlutils.relative_url(base, other)

635

504

            self.assertEqual(expected, result)

636

 

 

 

505

            

637

506

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

638

507

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

639

508

                    'http://entirely/different')

648

517

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

649

518

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

650

519

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

651

 

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

 

520

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

652

521

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

653

522

        # relative_url should preserve a trailing slash

654

523

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

666

535

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

667

536

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

668

537

 

669

 

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

670

 

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

671

 

        if sys.platform == 'win32':

672

 

            # on the same drive

673

 

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

674

 

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

675

 

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

676

 

            #~to see normalized file URLs?

677

 

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

678

 

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

679

 

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

680

 

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

681

 

 

682

 

            # check UNC paths too

683

 

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

684

 

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

685

 

            # on different drives

686

 

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

687

 

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

688

 

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

689

 

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

690

 

            # should be exception from rules. [bialix 20071221]

691

 

 

692

538

 

693

539

class TestCwdToURL(TestCaseInTempDir):

694

540

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

712

558

 

713

559

        os.chdir(u'dod\xe9')

714

560

 

715

 

        # On Mac OSX this directory is actually:

 

561

        # On Mac OSX this directory is actually: 

716

562

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

717

 

        # but we should normalize it back to

 

563

        # but we should normalize it back to 

718

564

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

719

565

        url = urlutils.local_path_to_url('.')

720

566

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

721

 

 

722

 

 

723

 

class TestDeriveToLocation(TestCase):

724

 

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

725

 

 

726

 

    def test_to_locations_derived_from_paths(self):

727

 

        derive = urlutils.derive_to_location

728

 

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

729

 

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

730

 

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

731

 

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

732

 

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

733

 

 

734

 

    def test_to_locations_derived_from_urls(self):

735

 

        derive = urlutils.derive_to_location

736

 

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

737

 

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

738

 

        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