~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

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

• reverse the comparison (2425.1.1 to 5462.5.3)
• stop comparing with revision 5462.5.3

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

344

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

423

345

        # Not a valid _win32 url, no drive letter

476

398

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

477

399

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

478

400

 

479

 

    def test_split_segment_parameters_raw(self):

480

 

        split_segment_parameters_raw = urlutils.split_segment_parameters_raw

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

488

 

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

489

 

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

490

 

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

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", []),

496

 

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

497

 

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

498

 

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

499

 

 

500

 

    def test_split_segment_parameters(self):

501

 

        split_segment_parameters = urlutils.split_segment_parameters

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

509

 

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

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

515

 

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

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", {}),

521

 

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

522

 

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

523

 

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

524

 

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

525

 

 

526

401

    def test_win32_strip_local_trailing_slash(self):

527

402

        strip = urlutils._win32_strip_local_trailing_slash

528

403

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

610

485

    def test_escape(self):

611

486

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

612

487

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

613

 

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

614

 

 

615

 

    def test_escape_tildes(self):

616

 

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

617

488

 

618

489

    def test_unescape(self):

619

490

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

631

502

        def test(expected, base, other):

632

503

            result = urlutils.relative_url(base, other)

633

504

            self.assertEqual(expected, result)

634

 

 

 

505

            

635

506

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

636

507

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

637

508

                    'http://entirely/different')

646

517

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

647

518

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

648

519

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

649

 

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

 

520

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

650

521

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

651

522

        # relative_url should preserve a trailing slash

652

523

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

664

535

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

665

536

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

666

537

 

667

 

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

668

 

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

669

 

        if sys.platform == 'win32':

670

 

            # on the same drive

671

 

            test('../../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')

679

 

 

680

 

            # check UNC paths too

681

 

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

682

 

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

683

 

            # on different drives

684

 

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

685

 

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

686

 

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

687

 

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

688

 

            # should be exception from rules. [bialix 20071221]

689

 

 

690

538

 

691

539

class TestCwdToURL(TestCaseInTempDir):

692

540

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

710

558

 

711

559

        os.chdir(u'dod\xe9')

712

560

 

713

 

        # On Mac OSX this directory is actually:

 

561

        # On Mac OSX this directory is actually: 

714

562

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

715

 

        # but we should normalize it back to

 

563

        # but we should normalize it back to 

716

564

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

717

565

        url = urlutils.local_path_to_url('.')

718

566

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

719

 

 

720

 

 

721

 

class TestDeriveToLocation(TestCase):

722

 

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

723

 

 

724

 

    def test_to_locations_derived_from_paths(self):

725

 

        derive = urlutils.derive_to_location

726

 

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

727

 

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

728

 

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

729

 

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

730

 

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

731

 

 

732

 

    def test_to_locations_derived_from_urls(self):

733

 

        derive = urlutils.derive_to_location

734

 

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

735

 

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

736

 

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

737

 

 

738

 

 

739

 

class TestRebaseURL(TestCase):

740

 

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

741

 

 

742

 

    def test_non_relative(self):

743

 

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

744

 

                                     'file://foo/bar')

745

 

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

746

 

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

747

 

                                     'file://foo/bar')

748

 

        self.assertEqual('/foo', result)

749

 

 

750

 

    def test_different_ports(self):

751

 

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

752

 

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

753

 

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

754

 

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

755

 

 

756

 

    def test_different_hosts(self):

757

 

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

758

 

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

759

 

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

760

 

                         " and 'http://baz'")

761

 

 

762

 

    def test_different_protocol(self):

763

 

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

764

 

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

765

 

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

766

 

                         " and 'ftp://bar'")

767

 

 

768

 

    def test_rebase_success(self):

769

 

        self.assertEqual('../bar', urlutils.rebase_url('bar', '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/'))

777

 

 

778

 

    def test_determine_relative_path(self):

779

 

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

780

 

                         urlutils.determine_relative_path(

781

 

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

782

 

        self.assertEqual('..',

783

 

                         urlutils.determine_relative_path(

784

 

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

785

 

        self.assertEqual('baz',

786

 

                         urlutils.determine_relative_path(

787

 

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

788

 

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

789

 

                         '/bar', '/bar'))

790

 

 

791

 

 

792

 

class TestParseURL(TestCase):

793

 

 

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

• Older »

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